commit 3ec306e485018e69f9de91ccae708b575cc02ce1 · dunkirk.sh/battleship-arena

+73

AGENTS.md

···

       19
       19
        
       

     

       20
       20
        
       Files must match pattern `memory_functions_*.cpp`

     

       21
       21
        
       

     

       22
       22
       +
       ## Required Function Signatures

     

       23
       23
       +
       

     

       24
       24
       +
       **IMPORTANT**: Your submission must implement exactly these three functions with these exact signatures:

     

       25
       25
       +
       

     

       26
       26
       +
       ```cpp

     

       27
       27
       +
       void initMemoryYOURNAME(ComputerMemory &memory);

     

       28
       28
       +
       string smartMoveYOURNAME(const ComputerMemory &memory);

     

       29
       29
       +
       void updateMemoryYOURNAME(int row, int col, int result, ComputerMemory &memory);

     

       30
       30
       +
       ```

     

       31
       31
       +
       

     

       32
       32
       +
       Replace `YOURNAME` with your chosen suffix (must match your filename `memory_functions_YOURNAME.cpp`).

     

       33
       33
       +
       

     

       34
       34
       +
       **Example** for `memory_functions_alice.cpp`:

     

       35
       35
       +
       ```cpp

     

       36
       36
       +
       #include "memory_functions_alice.h"

     

       37
       37
       +
       #include "battleship.h"

     

       38
       38
       +
       #include "kasbs.h"

     

       39
       39
       +
       #include "memory.h"

     

       40
       40
       +
       #include <string>

     

       41
       41
       +
       

     

       42
       42
       +
       using namespace std;

     

       43
       43
       +
       

     

       44
       44
       +
       inline string formatMove(int row, int col) {

     

       45
       45
       +
           char letter = static_cast<char>('A' + row);

     

       46
       46
       +
           return string(1, letter) + to_string(col + 1);

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       void initMemoryAlice(ComputerMemory &memory) {

     

       50
       50
       +
           // Initialize your memory structure

     

       51
       51
       +
           for (int i = 0; i < BOARDSIZE; i++) {

     

       52
       52
       +
               for (int j = 0; j < BOARDSIZE; j++) {

     

       53
       53
       +
                   memory.grid[i][j] = '?';

     

       54
       54
       +
               }

     

       55
       55
       +
           }

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       void updateMemoryAlice(int row, int col, int result, ComputerMemory &memory) {

     

       59
       59
       +
           // Update memory based on shot result

     

       60
       60
       +
           // result constants: HIT, MISS, SUNK (from kasbs.h)

     

       61
       61
       +
           if (result == HIT || result == SUNK) {

     

       62
       62
       +
               memory.grid[row][col] = 'h';

     

       63
       63
       +
           } else {

     

       64
       64
       +
               memory.grid[row][col] = 'm';

     

       65
       65
       +
           }

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

       68
       68
       +
       string smartMoveAlice(const ComputerMemory &memory) {

     

       69
       69
       +
           // Return your next move as a string (e.g., "A1", "B5", "J10")

     

       70
       70
       +
           int row = 0;  // your logic here

     

       71
       71
       +
           int col = 0;  // your logic here

     

       72
       72
       +
           return formatMove(row, col);

     

       73
       73
       +
       }

     

       74
       74
       +
       ```

     

       75
       75
       +
       

     

       76
       76
       +
       **Key Points**:

     

       77
       77
       +
       - Function names must match your filename suffix exactly (case-sensitive)

     

       78
       78
       +
       - Must return `string` from `smartMove`, not integer array

     

       79
       79
       +
       - Must use `ComputerMemory &` parameter, not custom structs

     

       80
       80
       +
       - Use `formatMove(row, col)` helper to convert coordinates to string format

     

       81
       81
       +
       - Result constants available: `HIT`, `MISS`, `SUNK` from `kasbs.h`

     

       82
       82
       +
       - Grid size constant: `BOARDSIZE` from `kasbs.h`

     

       83
       83
       +
       

     

       22
       84
        
       ## Testing Flow

     

       23
       85
        
       

     

       24
       86
        
       1. Student uploads file via SCP → saved to `./submissions/username/`

     
···

       49
       111
        
       See `Dockerfile`, `docker-compose.yml`, or `battleship-arena.service` for systemd.

     

       50
       112
        
       

     

       51
       113
        
       Web runs on port 8080, SSH on port 2222.

     

       114
       114
       +
       

     

       115
       115
       +
       ## Performance Stages

     

       116
       116
       +
       

     

       117
       117
       +
       Submissions are categorized into stages based on average moves per game:

     

       118
       118
       +
       

     

       119
       119
       +
       - **Expert** (<85 moves): Significantly better than random shooting

     

       120
       120
       +
       - **Advanced** (85-95 moves): Better than random shooting  

     

       121
       121
       +
       - **Intermediate** (95-99 moves): Around random shooting performance

     

       122
       122
       +
       - **Beginner** (≥99 moves): Worse than random shooting

     

       123
       123
       +
       

     

       124
       124
       +
       *Benchmark: Pure random shooting averages 95.5 moves over 1000 games (range: 64-100)*

+272 -6

database.go

···

       14
       14
        
       	Wins      int

     

       15
       15
        
       	Losses    int

     

       16
       16
        
       	AvgMoves  float64

     

       17
       17
       +
       	Stage     string

     

       17
       18
        
       	LastPlayed time.Time

     

       18
       19
        
       }

     

       19
       20
        
       

     
···

       25
       26
        
       	Status     string // pending, testing, completed, failed

     

       26
       27
        
       }

     

       27
       28
        
       

     

       29
       29
       +
       type Tournament struct {

     

       30
       30
       +
       	ID           int

     

       31
       31
       +
       	CreatedAt    time.Time

     

       32
       32
       +
       	Status       string // active, completed

     

       33
       33
       +
       	CurrentRound int

     

       34
       34
       +
       	WinnerID     int    // ID of winning submission

     

       35
       35
       +
       }

     

       36
       36
       +
       

     

       37
       37
       +
       type BracketMatch struct {

     

       38
       38
       +
       	ID           int

     

       39
       39
       +
       	TournamentID int

     

       40
       40
       +
       	Round        int

     

       41
       41
       +
       	Position     int

     

       42
       42
       +
       	Player1ID    int

     

       43
       43
       +
       	Player2ID    int

     

       44
       44
       +
       	WinnerID     int

     

       45
       45
       +
       	Player1Wins  int

     

       46
       46
       +
       	Player2Wins  int

     

       47
       47
       +
       	Player1Moves int

     

       48
       48
       +
       	Player2Moves int

     

       49
       49
       +
       	Status       string // pending, in_progress, completed

     

       50
       50
       +
       	Player1Name  string // For display

     

       51
       51
       +
       	Player2Name  string

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       28
       54
        
       func initDB(path string) (*sql.DB, error) {

     

       29
       55
        
       	db, err := sql.Open("sqlite3", path+"?parseTime=true")

     

       30
       56
        
       	if err != nil {

     
···

       41
       67
        
       		is_active BOOLEAN DEFAULT 1

     

       42
       68
        
       	);

     

       43
       69
        
       

     

       70
       70
       +
       	CREATE TABLE IF NOT EXISTS tournaments (

     

       71
       71
       +
       		id INTEGER PRIMARY KEY AUTOINCREMENT,

     

       72
       72
       +
       		created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

     

       73
       73
       +
       		status TEXT DEFAULT 'active',

     

       74
       74
       +
       		current_round INTEGER DEFAULT 1,

     

       75
       75
       +
       		winner_id INTEGER,

     

       76
       76
       +
       		FOREIGN KEY (winner_id) REFERENCES submissions(id)

     

       77
       77
       +
       	);

     

       78
       78
       +
       

     

       79
       79
       +
       	CREATE TABLE IF NOT EXISTS bracket_matches (

     

       80
       80
       +
       		id INTEGER PRIMARY KEY AUTOINCREMENT,

     

       81
       81
       +
       		tournament_id INTEGER,

     

       82
       82
       +
       		round INTEGER,

     

       83
       83
       +
       		position INTEGER,

     

       84
       84
       +
       		player1_id INTEGER,

     

       85
       85
       +
       		player2_id INTEGER,

     

       86
       86
       +
       		winner_id INTEGER,

     

       87
       87
       +
       		player1_wins INTEGER DEFAULT 0,

     

       88
       88
       +
       		player2_wins INTEGER DEFAULT 0,

     

       89
       89
       +
       		player1_moves INTEGER,

     

       90
       90
       +
       		player2_moves INTEGER,

     

       91
       91
       +
       		status TEXT DEFAULT 'pending',

     

       92
       92
       +
       		timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

     

       93
       93
       +
       		FOREIGN KEY (tournament_id) REFERENCES tournaments(id),

     

       94
       94
       +
       		FOREIGN KEY (player1_id) REFERENCES submissions(id),

     

       95
       95
       +
       		FOREIGN KEY (player2_id) REFERENCES submissions(id),

     

       96
       96
       +
       		FOREIGN KEY (winner_id) REFERENCES submissions(id)

     

       97
       97
       +
       	);

     

       98
       98
       +
       

     

       44
       99
        
       	CREATE TABLE IF NOT EXISTS matches (

     

       45
       100
        
       		id INTEGER PRIMARY KEY AUTOINCREMENT,

     

       46
       101
        
       		player1_id INTEGER,

     
···

       54
       109
        
       		FOREIGN KEY (winner_id) REFERENCES submissions(id)

     

       55
       110
        
       	);

     

       56
       111
        
       

     

       112
       112
       +
       	CREATE INDEX IF NOT EXISTS idx_bracket_matches_tournament ON bracket_matches(tournament_id);

     

       113
       113
       +
       	CREATE INDEX IF NOT EXISTS idx_bracket_matches_status ON bracket_matches(status);

     

       114
       114
       +
       	CREATE INDEX IF NOT EXISTS idx_tournaments_status ON tournaments(status);

     

       57
       115
        
       	CREATE INDEX IF NOT EXISTS idx_matches_player1 ON matches(player1_id);

     

       58
       116
        
       	CREATE INDEX IF NOT EXISTS idx_matches_player2 ON matches(player2_id);

     

       59
       117
        
       	CREATE INDEX IF NOT EXISTS idx_submissions_username ON submissions(username);

     
···

       69
       127
        
       	query := `

     

       70
       128
        
       	SELECT 

     

       71
       129
        
       		s.username,

     

       72
       72
       -
       		COUNT(CASE WHEN m.winner_id = s.id THEN 1 END) as wins,

     

       73
       73
       -
       		COUNT(CASE WHEN (m.player1_id = s.id OR m.player2_id = s.id) AND m.winner_id != s.id THEN 1 END) as losses,

     

       74
       74
       -
       		AVG(CASE WHEN m.player1_id = s.id THEN m.player1_moves ELSE m.player2_moves END) as avg_moves,

     

       75
       75
       -
       		MAX(m.timestamp) as last_played

     

       130
       130
       +
       		COUNT(CASE WHEN bm.winner_id = s.id THEN 1 END) as wins,

     

       131
       131
       +
       		COUNT(CASE WHEN (bm.player1_id = s.id OR bm.player2_id = s.id) AND bm.winner_id != s.id AND bm.winner_id IS NOT NULL THEN 1 END) as losses,

     

       132
       132
       +
       		AVG(CASE WHEN bm.player1_id = s.id THEN bm.player1_moves ELSE bm.player2_moves END) as avg_moves,

     

       133
       133
       +
       		MAX(bm.timestamp) as last_played

     

       76
       134
        
       	FROM submissions s

     

       77
       77
       -
       	LEFT JOIN matches m ON (m.player1_id = s.id OR m.player2_id = s.id)

     

       135
       135
       +
       	LEFT JOIN bracket_matches bm ON (bm.player1_id = s.id OR bm.player2_id = s.id) AND bm.status = 'completed'

     

       78
       136
        
       	WHERE s.is_active = 1

     

       79
       137
        
       	GROUP BY s.username

     

       80
       80
       -
       	HAVING COUNT(m.id) > 0

     

       138
       138
       +
       	HAVING COUNT(bm.id) > 0

     

       81
       139
        
       	ORDER BY wins DESC, losses ASC, avg_moves ASC

     

       82
       140
        
       	LIMIT ?

     

       83
       141
        
       	`

     
···

       100
       158
        
       		// Parse the timestamp string

     

       101
       159
        
       		e.LastPlayed, _ = time.Parse("2006-01-02 15:04:05", lastPlayed)

     

       102
       160
        
       		

     

       161
       161
       +
       		// Determine stage based on average moves

     

       162
       162
       +
       		// Based on random AI benchmark: avg=95.459, p25=94, p75=99

     

       163
       163
       +
       		if e.AvgMoves >= 99 {

     

       164
       164
       +
       			e.Stage = "Beginner"

     

       165
       165
       +
       		} else if e.AvgMoves >= 95 {

     

       166
       166
       +
       			e.Stage = "Intermediate"

     

       167
       167
       +
       		} else if e.AvgMoves >= 85 {

     

       168
       168
       +
       			e.Stage = "Advanced"

     

       169
       169
       +
       		} else {

     

       170
       170
       +
       			e.Stage = "Expert"

     

       171
       171
       +
       		}

     

       172
       172
       +
       		

     

       103
       173
        
       		entries = append(entries, e)

     

       104
       174
        
       	}

     

       105
       175
        
       

     
···

       248
       318
        
       	

     

       249
       319
        
       	return matches, rows.Err()

     

       250
       320
        
       }

     

       321
       321
       +
       

     

       322
       322
       +
       // Tournament functions

     

       323
       323
       +
       

     

       324
       324
       +
       func getActiveTournament() (*Tournament, error) {

     

       325
       325
       +
       	var t Tournament

     

       326
       326
       +
       	var winnerID sql.NullInt64

     

       327
       327
       +
       	err := globalDB.QueryRow(

     

       328
       328
       +
       		"SELECT id, created_at, status, current_round, winner_id FROM tournaments WHERE status = 'active' ORDER BY id DESC LIMIT 1",

     

       329
       329
       +
       	).Scan(&t.ID, &t.CreatedAt, &t.Status, &t.CurrentRound, &winnerID)

     

       330
       330
       +
       	

     

       331
       331
       +
       	if err == sql.ErrNoRows {

     

       332
       332
       +
       		return nil, nil

     

       333
       333
       +
       	}

     

       334
       334
       +
       	if winnerID.Valid {

     

       335
       335
       +
       		t.WinnerID = int(winnerID.Int64)

     

       336
       336
       +
       	}

     

       337
       337
       +
       	return &t, err

     

       338
       338
       +
       }

     

       339
       339
       +
       

     

       340
       340
       +
       func getLatestTournament() (*Tournament, error) {

     

       341
       341
       +
       	var t Tournament

     

       342
       342
       +
       	var winnerID sql.NullInt64

     

       343
       343
       +
       	err := globalDB.QueryRow(

     

       344
       344
       +
       		"SELECT id, created_at, status, current_round, winner_id FROM tournaments ORDER BY id DESC LIMIT 1",

     

       345
       345
       +
       	).Scan(&t.ID, &t.CreatedAt, &t.Status, &t.CurrentRound, &winnerID)

     

       346
       346
       +
       	

     

       347
       347
       +
       	if err == sql.ErrNoRows {

     

       348
       348
       +
       		return nil, nil

     

       349
       349
       +
       	}

     

       350
       350
       +
       	if winnerID.Valid {

     

       351
       351
       +
       		t.WinnerID = int(winnerID.Int64)

     

       352
       352
       +
       	}

     

       353
       353
       +
       	return &t, err

     

       354
       354
       +
       }

     

       355
       355
       +
       

     

       356
       356
       +
       func createTournament() (*Tournament, error) {

     

       357
       357
       +
       	result, err := globalDB.Exec("INSERT INTO tournaments (status, current_round) VALUES ('active', 1)")

     

       358
       358
       +
       	if err != nil {

     

       359
       359
       +
       		return nil, err

     

       360
       360
       +
       	}

     

       361
       361
       +
       	

     

       362
       362
       +
       	id, _ := result.LastInsertId()

     

       363
       363
       +
       	return &Tournament{

     

       364
       364
       +
       		ID:           int(id),

     

       365
       365
       +
       		Status:       "active",

     

       366
       366
       +
       		CurrentRound: 1,

     

       367
       367
       +
       	}, nil

     

       368
       368
       +
       }

     

       369
       369
       +
       

     

       370
       370
       +
       func updateTournamentRound(tournamentID, round int) error {

     

       371
       371
       +
       	_, err := globalDB.Exec("UPDATE tournaments SET current_round = ? WHERE id = ?", round, tournamentID)

     

       372
       372
       +
       	return err

     

       373
       373
       +
       }

     

       374
       374
       +
       

     

       375
       375
       +
       func completeTournament(tournamentID, winnerID int) error {

     

       376
       376
       +
       	_, err := globalDB.Exec("UPDATE tournaments SET status = 'completed', winner_id = ? WHERE id = ?", winnerID, tournamentID)

     

       377
       377
       +
       	return err

     

       378
       378
       +
       }

     

       379
       379
       +
       

     

       380
       380
       +
       func addBracketMatch(tournamentID, round, position, player1ID, player2ID int) error {

     

       381
       381
       +
       	_, err := globalDB.Exec(

     

       382
       382
       +
       		"INSERT INTO bracket_matches (tournament_id, round, position, player1_id, player2_id, status) VALUES (?, ?, ?, ?, ?, 'pending')",

     

       383
       383
       +
       		tournamentID, round, position, player1ID, player2ID,

     

       384
       384
       +
       	)

     

       385
       385
       +
       	return err

     

       386
       386
       +
       }

     

       387
       387
       +
       

     

       388
       388
       +
       func getPendingBracketMatches(tournamentID int) ([]BracketMatch, error) {

     

       389
       389
       +
       	query := `

     

       390
       390
       +
       	SELECT 

     

       391
       391
       +
       		bm.id, bm.tournament_id, bm.round, bm.position,

     

       392
       392
       +
       		bm.player1_id, bm.player2_id, bm.winner_id,

     

       393
       393
       +
       		bm.player1_wins, bm.player2_wins,

     

       394
       394
       +
       		bm.player1_moves, bm.player2_moves, bm.status,

     

       395
       395
       +
       		s1.username as player1_name, s2.username as player2_name

     

       396
       396
       +
       	FROM bracket_matches bm

     

       397
       397
       +
       	JOIN submissions s1 ON bm.player1_id = s1.id

     

       398
       398
       +
       	JOIN submissions s2 ON bm.player2_id = s2.id

     

       399
       399
       +
       	WHERE bm.tournament_id = ? AND bm.status = 'pending'

     

       400
       400
       +
       	ORDER BY bm.round, bm.position

     

       401
       401
       +
       	`

     

       402
       402
       +
       	

     

       403
       403
       +
       	rows, err := globalDB.Query(query, tournamentID)

     

       404
       404
       +
       	if err != nil {

     

       405
       405
       +
       		return nil, err

     

       406
       406
       +
       	}

     

       407
       407
       +
       	defer rows.Close()

     

       408
       408
       +
       	

     

       409
       409
       +
       	var matches []BracketMatch

     

       410
       410
       +
       	for rows.Next() {

     

       411
       411
       +
       		var m BracketMatch

     

       412
       412
       +
       		var winnerID sql.NullInt64

     

       413
       413
       +
       		var player1Moves, player2Moves sql.NullInt64

     

       414
       414
       +
       		err := rows.Scan(

     

       415
       415
       +
       			&m.ID, &m.TournamentID, &m.Round, &m.Position,

     

       416
       416
       +
       			&m.Player1ID, &m.Player2ID, &winnerID,

     

       417
       417
       +
       			&m.Player1Wins, &m.Player2Wins,

     

       418
       418
       +
       			&player1Moves, &player2Moves, &m.Status,

     

       419
       419
       +
       			&m.Player1Name, &m.Player2Name,

     

       420
       420
       +
       		)

     

       421
       421
       +
       		if err != nil {

     

       422
       422
       +
       			return nil, err

     

       423
       423
       +
       		}

     

       424
       424
       +
       		if winnerID.Valid {

     

       425
       425
       +
       			m.WinnerID = int(winnerID.Int64)

     

       426
       426
       +
       		}

     

       427
       427
       +
       		if player1Moves.Valid {

     

       428
       428
       +
       			m.Player1Moves = int(player1Moves.Int64)

     

       429
       429
       +
       		}

     

       430
       430
       +
       		if player2Moves.Valid {

     

       431
       431
       +
       			m.Player2Moves = int(player2Moves.Int64)

     

       432
       432
       +
       		}

     

       433
       433
       +
       		matches = append(matches, m)

     

       434
       434
       +
       	}

     

       435
       435
       +
       	

     

       436
       436
       +
       	return matches, rows.Err()

     

       437
       437
       +
       }

     

       438
       438
       +
       

     

       439
       439
       +
       func getAllBracketMatches(tournamentID int) ([]BracketMatch, error) {

     

       440
       440
       +
       	query := `

     

       441
       441
       +
       	SELECT 

     

       442
       442
       +
       		bm.id, bm.tournament_id, bm.round, bm.position,

     

       443
       443
       +
       		bm.player1_id, bm.player2_id, bm.winner_id,

     

       444
       444
       +
       		bm.player1_wins, bm.player2_wins,

     

       445
       445
       +
       		bm.player1_moves, bm.player2_moves, bm.status,

     

       446
       446
       +
       		s1.username as player1_name, s2.username as player2_name

     

       447
       447
       +
       	FROM bracket_matches bm

     

       448
       448
       +
       	LEFT JOIN submissions s1 ON bm.player1_id = s1.id

     

       449
       449
       +
       	LEFT JOIN submissions s2 ON bm.player2_id = s2.id

     

       450
       450
       +
       	WHERE bm.tournament_id = ?

     

       451
       451
       +
       	ORDER BY bm.round, bm.position

     

       452
       452
       +
       	`

     

       453
       453
       +
       	

     

       454
       454
       +
       	rows, err := globalDB.Query(query, tournamentID)

     

       455
       455
       +
       	if err != nil {

     

       456
       456
       +
       		return nil, err

     

       457
       457
       +
       	}

     

       458
       458
       +
       	defer rows.Close()

     

       459
       459
       +
       	

     

       460
       460
       +
       	var matches []BracketMatch

     

       461
       461
       +
       	for rows.Next() {

     

       462
       462
       +
       		var m BracketMatch

     

       463
       463
       +
       		var player1Name, player2Name sql.NullString

     

       464
       464
       +
       		var winnerID, player1Moves, player2Moves sql.NullInt64

     

       465
       465
       +
       		err := rows.Scan(

     

       466
       466
       +
       			&m.ID, &m.TournamentID, &m.Round, &m.Position,

     

       467
       467
       +
       			&m.Player1ID, &m.Player2ID, &winnerID,

     

       468
       468
       +
       			&m.Player1Wins, &m.Player2Wins,

     

       469
       469
       +
       			&player1Moves, &player2Moves, &m.Status,

     

       470
       470
       +
       			&player1Name, &player2Name,

     

       471
       471
       +
       		)

     

       472
       472
       +
       		if err != nil {

     

       473
       473
       +
       			return nil, err

     

       474
       474
       +
       		}

     

       475
       475
       +
       		if winnerID.Valid {

     

       476
       476
       +
       			m.WinnerID = int(winnerID.Int64)

     

       477
       477
       +
       		}

     

       478
       478
       +
       		if player1Moves.Valid {

     

       479
       479
       +
       			m.Player1Moves = int(player1Moves.Int64)

     

       480
       480
       +
       		}

     

       481
       481
       +
       		if player2Moves.Valid {

     

       482
       482
       +
       			m.Player2Moves = int(player2Moves.Int64)

     

       483
       483
       +
       		}

     

       484
       484
       +
       		if player1Name.Valid {

     

       485
       485
       +
       			m.Player1Name = player1Name.String

     

       486
       486
       +
       		}

     

       487
       487
       +
       		if player2Name.Valid {

     

       488
       488
       +
       			m.Player2Name = player2Name.String

     

       489
       489
       +
       		}

     

       490
       490
       +
       		matches = append(matches, m)

     

       491
       491
       +
       	}

     

       492
       492
       +
       	

     

       493
       493
       +
       	return matches, rows.Err()

     

       494
       494
       +
       }

     

       495
       495
       +
       

     

       496
       496
       +
       func updateBracketMatchResult(matchID, winnerID, player1Wins, player2Wins, player1Moves, player2Moves int) error {

     

       497
       497
       +
       	_, err := globalDB.Exec(

     

       498
       498
       +
       		`UPDATE bracket_matches 

     

       499
       499
       +
       		SET winner_id = ?, player1_wins = ?, player2_wins = ?, 

     

       500
       500
       +
       		    player1_moves = ?, player2_moves = ?, status = 'completed' 

     

       501
       501
       +
       		WHERE id = ?`,

     

       502
       502
       +
       		winnerID, player1Wins, player2Wins, player1Moves, player2Moves, matchID,

     

       503
       503
       +
       	)

     

       504
       504
       +
       	return err

     

       505
       505
       +
       }

     

       506
       506
       +
       

     

       507
       507
       +
       func isRoundComplete(tournamentID, round int) (bool, error) {

     

       508
       508
       +
       	var pendingCount int

     

       509
       509
       +
       	err := globalDB.QueryRow(

     

       510
       510
       +
       		"SELECT COUNT(*) FROM bracket_matches WHERE tournament_id = ? AND round = ? AND status != 'completed'",

     

       511
       511
       +
       		tournamentID, round,

     

       512
       512
       +
       	).Scan(&pendingCount)

     

       513
       513
       +
       	

     

       514
       514
       +
       	return pendingCount == 0, err

     

       515
       515
       +
       }

     

       516
       516
       +

main.go

···

       114
       114
        
       	mux.HandleFunc("/api/leaderboard", handleAPILeaderboard)

     

       115
       115
        
       	mux.HandleFunc("/api/bracket", handleBracketData)

     

       116
       116
        
       	

     

       117
       117
       +
       	// Serve static files

     

       118
       118
       +
       	fs := http.FileServer(http.Dir("./static"))

     

       119
       119
       +
       	mux.Handle("/static/", http.StripPrefix("/static/", fs))

     

       120
       120
       +
       	

     

       117
       121
        
       	log.Printf("Web server starting on :%s", webPort)

     

       118
       122
        
       	if err := http.ListenAndServe(":"+webPort, mux); err != nil {

     

       119
       123
        
       		log.Fatal(err)

+19 -5

model.go

···

       189
       189
        
       	b.WriteString(lipgloss.NewStyle().Bold(true).Render("🏆 Leaderboard") + "\n\n")

     

       190
       190
        
       

     

       191
       191
        
       	// Header without styling on the whole line

     

       192
       192
       -
       	b.WriteString(fmt.Sprintf("%-4s %-20s %8s %8s %10s\n", 

     

       193
       193
       -
       		"Rank", "User", "Wins", "Losses", "Win Rate"))

     

       192
       192
       +
       	b.WriteString(fmt.Sprintf("%-4s %-20s %-12s %8s %8s %10s %10s\n", 

     

       193
       193
       +
       		"Rank", "User", "Stage", "Wins", "Losses", "Win Rate", "Avg Moves"))

     

       194
       194
        
       

     

       195
       195
        
       	for i, entry := range entries {

     

       196
       196
        
       		winRate := 0.0

     
···

       213
       213
        
       			coloredRank = rank

     

       214
       214
        
       		}

     

       215
       215
        
       		

     

       216
       216
       -
       		// Format line with proper spacing, only rank is colored

     

       217
       217
       -
       		b.WriteString(fmt.Sprintf("%-4s %-20s %8d %8d %9.2f%%\n",

     

       218
       218
       -
       			coloredRank, entry.Username, entry.Wins, entry.Losses, winRate))

     

       216
       216
       +
       		// Color stage badge

     

       217
       217
       +
       		var stageColor string

     

       218
       218
       +
       		switch entry.Stage {

     

       219
       219
       +
       		case "Expert":

     

       220
       220
       +
       			stageColor = "green"

     

       221
       221
       +
       		case "Advanced":

     

       222
       222
       +
       			stageColor = "blue"

     

       223
       223
       +
       		case "Intermediate":

     

       224
       224
       +
       			stageColor = "yellow"

     

       225
       225
       +
       		default:

     

       226
       226
       +
       			stageColor = "240"

     

       227
       227
       +
       		}

     

       228
       228
       +
       		coloredStage := lipgloss.NewStyle().Foreground(lipgloss.Color(stageColor)).Render(entry.Stage)

     

       229
       229
       +
       		

     

       230
       230
       +
       		// Format line with proper spacing

     

       231
       231
       +
       		b.WriteString(fmt.Sprintf("%-4s %-20s %-12s %8d %8d %9.2f%% %9.1f\n",

     

       232
       232
       +
       			coloredRank, entry.Username, coloredStage, entry.Wins, entry.Losses, winRate, entry.AvgMoves))

     

       219
       233
        
       	}

     

       220
       234
        
       

     

       221
       235
        
       	return b.String()

+118 -6

runner.go

···

       31
       31
        
       		log.Printf("Submission %d compiled successfully: %s by %s", sub.ID, sub.Filename, sub.Username)

     

       32
       32
        
       		updateSubmissionStatus(sub.ID, "completed")

     

       33
       33
        
       		

     

       34
       34
       -
       		// Run tournament matches against all active submissions

     

       35
       35
       -
       		go runTournamentMatches(sub)

     

       34
       34
       +
       		// Tournament will be created/updated by processBracketMatches

     

       35
       35
       +
       		log.Printf("Submission %d ready for tournament", sub.ID)

     

       36
       36
        
       	}

     

       37
       37
        
       

     

       38
       38
        
       	return nil

     
···

       128
       128
        
       	return nil

     

       129
       129
        
       }

     

       130
       130
        
       

     

       131
       131
       +
       func processBracketMatches() error {

     

       132
       132
       +
       	// Ensure tournament exists

     

       133
       133
       +
       	tournament, err := ensureTournamentExists()

     

       134
       134
       +
       	if err != nil {

     

       135
       135
       +
       		return fmt.Errorf("failed to ensure tournament: %v", err)

     

       136
       136
       +
       	}

     

       137
       137
       +
       	

     

       138
       138
       +
       	if tournament.Status != "active" {

     

       139
       139
       +
       		log.Println("Tournament is complete, skipping match processing")

     

       140
       140
       +
       		return nil

     

       141
       141
       +
       	}

     

       142
       142
       +
       	

     

       143
       143
       +
       	// Get pending matches for current tournament

     

       144
       144
       +
       	matches, err := getPendingBracketMatches(tournament.ID)

     

       145
       145
       +
       	if err != nil {

     

       146
       146
       +
       		return fmt.Errorf("failed to get pending matches: %v", err)

     

       147
       147
       +
       	}

     

       148
       148
       +
       	

     

       149
       149
       +
       	if len(matches) == 0 {

     

       150
       150
       +
       		log.Println("No pending bracket matches")

     

       151
       151
       +
       		return nil

     

       152
       152
       +
       	}

     

       153
       153
       +
       	

     

       154
       154
       +
       	// Process each match

     

       155
       155
       +
       	for _, match := range matches {

     

       156
       156
       +
       		log.Printf("Running bracket match: %s vs %s (Round %d, Position %d)", 

     

       157
       157
       +
       			match.Player1Name, match.Player2Name, match.Round, match.Position)

     

       158
       158
       +
       		

     

       159
       159
       +
       		// Get submission details

     

       160
       160
       +
       		player1, err := getSubmissionByID(match.Player1ID)

     

       161
       161
       +
       		if err != nil {

     

       162
       162
       +
       			log.Printf("Failed to get player1 submission: %v", err)

     

       163
       163
       +
       			continue

     

       164
       164
       +
       		}

     

       165
       165
       +
       		

     

       166
       166
       +
       		player2, err := getSubmissionByID(match.Player2ID)

     

       167
       167
       +
       		if err != nil {

     

       168
       168
       +
       			log.Printf("Failed to get player2 submission: %v", err)

     

       169
       169
       +
       			continue

     

       170
       170
       +
       		}

     

       171
       171
       +
       		

     

       172
       172
       +
       		// Run head-to-head match (1000 games)

     

       173
       173
       +
       		player1Wins, player2Wins, totalMoves := runHeadToHead(player1, player2, 1000)

     

       174
       174
       +
       		

     

       175
       175
       +
       		avgMovesP1 := totalMoves / 2000  // Each player plays ~500 games

     

       176
       176
       +
       		avgMovesP2 := avgMovesP1

     

       177
       177
       +
       		

     

       178
       178
       +
       		// Determine winner

     

       179
       179
       +
       		var winnerID int

     

       180
       180
       +
       		if player1Wins > player2Wins {

     

       181
       181
       +
       			winnerID = match.Player1ID

     

       182
       182
       +
       			log.Printf("Match result: %s wins (%d-%d)", match.Player1Name, player1Wins, player2Wins)

     

       183
       183
       +
       		} else if player2Wins > player1Wins {

     

       184
       184
       +
       			winnerID = match.Player2ID

     

       185
       185
       +
       			log.Printf("Match result: %s wins (%d-%d)", match.Player2Name, player2Wins, player1Wins)

     

       186
       186
       +
       		} else {

     

       187
       187
       +
       			// Tie - better average moves wins

     

       188
       188
       +
       			if avgMovesP1 < avgMovesP2 {

     

       189
       189
       +
       				winnerID = match.Player1ID

     

       190
       190
       +
       			} else {

     

       191
       191
       +
       				winnerID = match.Player2ID

     

       192
       192
       +
       			}

     

       193
       193
       +
       			log.Printf("Match result: Tie %d-%d, winner by avg moves: ID %d", player1Wins, player2Wins, winnerID)

     

       194
       194
       +
       		}

     

       195
       195
       +
       		

     

       196
       196
       +
       		// Update match result

     

       197
       197
       +
       		err = updateBracketMatchResult(match.ID, winnerID, player1Wins, player2Wins, avgMovesP1, avgMovesP2)

     

       198
       198
       +
       		if err != nil {

     

       199
       199
       +
       			log.Printf("Failed to update bracket match: %v", err)

     

       200
       200
       +
       			continue

     

       201
       201
       +
       		}

     

       202
       202
       +
       	}

     

       203
       203
       +
       	

     

       204
       204
       +
       	// Check if current round is complete

     

       205
       205
       +
       	complete, err := isRoundComplete(tournament.ID, tournament.CurrentRound)

     

       206
       206
       +
       	if err != nil {

     

       207
       207
       +
       		return fmt.Errorf("failed to check round completion: %v", err)

     

       208
       208
       +
       	}

     

       209
       209
       +
       	

     

       210
       210
       +
       	if complete {

     

       211
       211
       +
       		log.Printf("Round %d complete, advancing winners", tournament.CurrentRound)

     

       212
       212
       +
       		err = advanceWinners(tournament.ID, tournament.CurrentRound)

     

       213
       213
       +
       		if err != nil {

     

       214
       214
       +
       			return fmt.Errorf("failed to advance winners: %v", err)

     

       215
       215
       +
       		}

     

       216
       216
       +
       	}

     

       217
       217
       +
       	

     

       218
       218
       +
       	return nil

     

       219
       219
       +
       }

     

       220
       220
       +
       

     

       221
       221
       +
       func getSubmissionByID(id int) (Submission, error) {

     

       222
       222
       +
       	var sub Submission

     

       223
       223
       +
       	err := globalDB.QueryRow(

     

       224
       224
       +
       		"SELECT id, username, filename, upload_time, status FROM submissions WHERE id = ?",

     

       225
       225
       +
       		id,

     

       226
       226
       +
       	).Scan(&sub.ID, &sub.Username, &sub.Filename, &sub.UploadTime, &sub.Status)

     

       227
       227
       +
       	return sub, err

     

       228
       228
       +
       }

     

       229
       229
       +
       

     

       230
       230
       +
       // Deprecated: replaced by bracket tournament

     

       131
       231
        
       func runTournamentMatches(newSub Submission) {

     

       132
       232
        
       	// Get all active submissions

     

       133
       233
        
       	activeSubmissions, err := getActiveSubmissions()

     
···

       228
       328
        
       	}

     

       229
       329
        
       	

     

       230
       330
        
       	// Compile combined binary

     

       231
       231
       -
       	cmd := exec.Command("g++", "-std=c++11", "-O3",

     

       331
       331
       +
       	compileArgs := []string{"-std=c++11", "-O3",

     

       232
       332
        
       		"-o", combinedBinary,

     

       233
       333
        
       		mainPath,

     

       234
       334
        
       		filepath.Join(enginePath, "src", "battleship_light.cpp"),

     

       235
       235
       -
       		filepath.Join(enginePath, "src", fmt.Sprintf("memory_functions_%s.cpp", prefix1)),

     

       236
       236
       -
       		filepath.Join(enginePath, "src", fmt.Sprintf("memory_functions_%s.cpp", prefix2)),

     

       237
       237
       -
       	)

     

       335
       335
       +
       	}

     

       336
       336
       +
       	

     

       337
       337
       +
       	// Add player files (avoid duplicates if same AI)

     

       338
       338
       +
       	if prefix1 == prefix2 {

     

       339
       339
       +
       		// Same AI - only compile once

     

       340
       340
       +
       		compileArgs = append(compileArgs, filepath.Join(enginePath, "src", fmt.Sprintf("memory_functions_%s.cpp", prefix1)))

     

       341
       341
       +
       	} else {

     

       342
       342
       +
       		// Different AIs

     

       343
       343
       +
       		compileArgs = append(compileArgs,

     

       344
       344
       +
       			filepath.Join(enginePath, "src", fmt.Sprintf("memory_functions_%s.cpp", prefix1)),

     

       345
       345
       +
       			filepath.Join(enginePath, "src", fmt.Sprintf("memory_functions_%s.cpp", prefix2)),

     

       346
       346
       +
       		)

     

       347
       347
       +
       	}

     

       348
       348
       +
       	

     

       349
       349
       +
       	cmd := exec.Command("g++", compileArgs...)

     

       238
       350
        
       	output, err := cmd.CombinedOutput()

     

       239
       351
        
       	if err != nil {

     

       240
       352
        
       		log.Printf("Failed to compile match binary: %s", output)

scripts/benchmark_random

This is a binary file and will not be displayed.

+130

scripts/benchmark_random.cpp

···

       1
       1
       +
       #include <iostream>

     

       2
       2
       +
       #include <vector>

     

       3
       3
       +
       #include <algorithm>

     

       4
       4
       +
       #include <numeric>

     

       5
       5
       +
       #include <cstdlib>

     

       6
       6
       +
       #include <ctime>

     

       7
       7
       +
       

     

       8
       8
       +
       using namespace std;

     

       9
       9
       +
       

     

       10
       10
       +
       const int BOARDSIZE = 10;

     

       11
       11
       +
       

     

       12
       12
       +
       // Simple coordinate parsing

     

       13
       13
       +
       pair<int, int> parseMove(const string& move) {

     

       14
       14
       +
           int row = move[0] - 'A';

     

       15
       15
       +
           int col = stoi(move.substr(1)) - 1;

     

       16
       16
       +
           return {row, col};

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

       19
       19
       +
       int runSingleGame() {

     

       20
       20
       +
           char board[BOARDSIZE][BOARDSIZE];

     

       21
       21
       +
           

     

       22
       22
       +
           // Initialize board

     

       23
       23
       +
           for (int i = 0; i < BOARDSIZE; i++) {

     

       24
       24
       +
               for (int j = 0; j < BOARDSIZE; j++) {

     

       25
       25
       +
                   board[i][j] = '.';

     

       26
       26
       +
               }

     

       27
       27
       +
           }

     

       28
       28
       +
           

     

       29
       29
       +
           // Place ships randomly

     

       30
       30
       +
           int shipSizes[] = {5, 4, 3, 3, 2};

     

       31
       31
       +
           for (int s = 0; s < 5; s++) {

     

       32
       32
       +
               bool placed = false;

     

       33
       33
       +
               while (!placed) {

     

       34
       34
       +
                   int row = rand() % BOARDSIZE;

     

       35
       35
       +
                   int col = rand() % BOARDSIZE;

     

       36
       36
       +
                   int orient = rand() % 2;

     

       37
       37
       +
                   

     

       38
       38
       +
                   bool canPlace = true;

     

       39
       39
       +
                   for (int i = 0; i < shipSizes[s]; i++) {

     

       40
       40
       +
                       int r = row + (orient == 1 ? i : 0);

     

       41
       41
       +
                       int c = col + (orient == 0 ? i : 0);

     

       42
       42
       +
                       if (r >= BOARDSIZE || c >= BOARDSIZE || board[r][c] == 'S') {

     

       43
       43
       +
                           canPlace = false;

     

       44
       44
       +
                           break;

     

       45
       45
       +
                       }

     

       46
       46
       +
                   }

     

       47
       47
       +
                   

     

       48
       48
       +
                   if (canPlace) {

     

       49
       49
       +
                       for (int i = 0; i < shipSizes[s]; i++) {

     

       50
       50
       +
                           int r = row + (orient == 1 ? i : 0);

     

       51
       51
       +
                           int c = col + (orient == 0 ? i : 0);

     

       52
       52
       +
                           board[r][c] = 'S';

     

       53
       53
       +
                       }

     

       54
       54
       +
                       placed = true;

     

       55
       55
       +
                   }

     

       56
       56
       +
               }

     

       57
       57
       +
           }

     

       58
       58
       +
           

     

       59
       59
       +
           // Random shooting

     

       60
       60
       +
           vector<pair<int,int>> allCells;

     

       61
       61
       +
           for (int i = 0; i < BOARDSIZE; i++) {

     

       62
       62
       +
               for (int j = 0; j < BOARDSIZE; j++) {

     

       63
       63
       +
                   allCells.push_back({i, j});

     

       64
       64
       +
               }

     

       65
       65
       +
           }

     

       66
       66
       +
           

     

       67
       67
       +
           // Shuffle cells

     

       68
       68
       +
           for (int i = allCells.size() - 1; i > 0; i--) {

     

       69
       69
       +
               int j = rand() % (i + 1);

     

       70
       70
       +
               swap(allCells[i], allCells[j]);

     

       71
       71
       +
           }

     

       72
       72
       +
           

     

       73
       73
       +
           // Shoot until all ships found

     

       74
       74
       +
           int moves = 0;

     

       75
       75
       +
           int shipsRemaining = 17; // 5+4+3+3+2

     

       76
       76
       +
           

     

       77
       77
       +
           for (size_t i = 0; i < allCells.size(); i++) {

     

       78
       78
       +
               int row = allCells[i].first;

     

       79
       79
       +
               int col = allCells[i].second;

     

       80
       80
       +
               moves++;

     

       81
       81
       +
               if (board[row][col] == 'S') {

     

       82
       82
       +
                   shipsRemaining--;

     

       83
       83
       +
                   if (shipsRemaining == 0) break;

     

       84
       84
       +
               }

     

       85
       85
       +
           }

     

       86
       86
       +
           

     

       87
       87
       +
           return moves;

     

       88
       88
       +
       }

     

       89
       89
       +
       

     

       90
       90
       +
       int main() {

     

       91
       91
       +
           const int numGames = 1000;

     

       92
       92
       +
           vector<int> moveCounts;

     

       93
       93
       +
           

     

       94
       94
       +
           srand(time(NULL));

     

       95
       95
       +
           

     

       96
       96
       +
           cout << "Running " << numGames << " games with random AI..." << endl;

     

       97
       97
       +
           

     

       98
       98
       +
           for (int i = 0; i < numGames; i++) {

     

       99
       99
       +
               int moves = runSingleGame();

     

       100
       100
       +
               moveCounts.push_back(moves);

     

       101
       101
       +
               if ((i + 1) % 100 == 0) {

     

       102
       102
       +
                   cout << "Completed " << (i + 1) << " games..." << endl;

     

       103
       103
       +
               }

     

       104
       104
       +
           }

     

       105
       105
       +
           

     

       106
       106
       +
           // Calculate statistics

     

       107
       107
       +
           sort(moveCounts.begin(), moveCounts.end());

     

       108
       108
       +
           int minMoves = moveCounts.front();

     

       109
       109
       +
           int maxMoves = moveCounts.back();

     

       110
       110
       +
           double avg = accumulate(moveCounts.begin(), moveCounts.end(), 0.0) / moveCounts.size();

     

       111
       111
       +
           int median = moveCounts[moveCounts.size() / 2];

     

       112
       112
       +
           int p25 = moveCounts[moveCounts.size() / 4];

     

       113
       113
       +
           int p75 = moveCounts[3 * moveCounts.size() / 4];

     

       114
       114
       +
           

     

       115
       115
       +
           cout << "\n=== Random AI Statistics (1000 games) ===" << endl;

     

       116
       116
       +
           cout << "Min moves: " << minMoves << endl;

     

       117
       117
       +
           cout << "25th percentile: " << p25 << endl;

     

       118
       118
       +
           cout << "Median moves: " << median << endl;

     

       119
       119
       +
           cout << "Average moves: " << avg << endl;

     

       120
       120
       +
           cout << "75th percentile: " << p75 << endl;

     

       121
       121
       +
           cout << "Max moves: " << maxMoves << endl;

     

       122
       122
       +
           

     

       123
       123
       +
           cout << "\n=== Suggested Stage Thresholds ===" << endl;

     

       124
       124
       +
           cout << "Stage 1 (Beginner): >" << p75 << " avg moves (worse than random)" << endl;

     

       125
       125
       +
           cout << "Stage 2 (Intermediate): " << static_cast<int>(avg) << "-" << p75 << " avg moves (around random average)" << endl;

     

       126
       126
       +
           cout << "Stage 3 (Advanced): " << p25 << "-" << static_cast<int>(avg) << " avg moves (better than random)" << endl;

     

       127
       127
       +
           cout << "Stage 4 (Expert): <" << p25 << " avg moves (much better than random)" << endl;

     

       128
       128
       +
           

     

       129
       129
       +
           return 0;

     

       130
       130
       +
       }

+134

scripts/test-submissions/memory_functions_cluster.cpp

···

       1
       1
       +
       // Cluster AI - targets high-density regions where ships are likely clustered

     

       2
       2
       +
       // Strategy: Focus fire on promising areas before moving to next cluster

     

       3
       3
       +
       

     

       4
       4
       +
       #include "memory_functions_cluster.h"

     

       5
       5
       +
       #include "battleship.h"

     

       6
       6
       +
       #include "kasbs.h"

     

       7
       7
       +
       #include "memory.h"

     

       8
       8
       +
       #include <string>

     

       9
       9
       +
       #include <cstdlib>

     

       10
       10
       +
       #include <ctime>

     

       11
       11
       +
       

     

       12
       12
       +
       using namespace std;

     

       13
       13
       +
       

     

       14
       14
       +
       static int densityMap[BOARDSIZE][BOARDSIZE];

     

       15
       15
       +
       static int clusterCenterRow = -1;

     

       16
       16
       +
       static int clusterCenterCol = -1;

     

       17
       17
       +
       static int shotsInCurrentCluster = 0;

     

       18
       18
       +
       static const int maxShotsPerCluster = 12;

     

       19
       19
       +
       

     

       20
       20
       +
       inline string formatMove(int row, int col) {

     

       21
       21
       +
           char letter = static_cast<char>('A' + row);

     

       22
       22
       +
           return string(1, letter) + to_string(col + 1);

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       void initMemoryCluster(ComputerMemory &memory) {

     

       26
       26
       +
           srand(time(NULL));

     

       27
       27
       +
           

     

       28
       28
       +
           for (int i = 0; i < BOARDSIZE; i++) {

     

       29
       29
       +
               for (int j = 0; j < BOARDSIZE; j++) {

     

       30
       30
       +
                   memory.grid[i][j] = '?';

     

       31
       31
       +
                   densityMap[i][j] = 0;

     

       32
       32
       +
               }

     

       33
       33
       +
           }

     

       34
       34
       +
           

     

       35
       35
       +
           clusterCenterRow = -1;

     

       36
       36
       +
           clusterCenterCol = -1;

     

       37
       37
       +
           shotsInCurrentCluster = 0;

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       void updateMemoryCluster(int row, int col, int result, ComputerMemory &memory) {

     

       41
       41
       +
           if (result == HIT || result == SUNK) {

     

       42
       42
       +
               memory.grid[row][col] = 'h';

     

       43
       43
       +
               

     

       44
       44
       +
               // Increase density around hits

     

       45
       45
       +
               for (int i = row - 2; i <= row + 2; i++) {

     

       46
       46
       +
                   for (int j = col - 2; j <= col + 2; j++) {

     

       47
       47
       +
                       if (i >= 0 && i < BOARDSIZE && j >= 0 && j < BOARDSIZE) {

     

       48
       48
       +
                           densityMap[i][j] += 10;

     

       49
       49
       +
                       }

     

       50
       50
       +
                   }

     

       51
       51
       +
               }

     

       52
       52
       +
           } else {

     

       53
       53
       +
               memory.grid[row][col] = 'm';

     

       54
       54
       +
               

     

       55
       55
       +
               // Decrease density around misses

     

       56
       56
       +
               for (int i = row - 1; i <= row + 1; i++) {

     

       57
       57
       +
                   for (int j = col - 1; j <= col + 1; j++) {

     

       58
       58
       +
                       if (i >= 0 && i < BOARDSIZE && j >= 0 && j < BOARDSIZE) {

     

       59
       59
       +
                           densityMap[i][j] -= 2;

     

       60
       60
       +
                           if (densityMap[i][j] < 0) densityMap[i][j] = 0;

     

       61
       61
       +
                       }

     

       62
       62
       +
                   }

     

       63
       63
       +
               }

     

       64
       64
       +
           }

     

       65
       65
       +
       }

     

       66
       66
       +
       

     

       67
       67
       +
       void findBestCluster(int* centerRow, int* centerCol, const ComputerMemory &memory) {

     

       68
       68
       +
           int maxDensity = -1;

     

       69
       69
       +
           *centerRow = -1;

     

       70
       70
       +
           *centerCol = -1;

     

       71
       71
       +
           

     

       72
       72
       +
           for (int i = 1; i < BOARDSIZE - 1; i++) {

     

       73
       73
       +
               for (int j = 1; j < BOARDSIZE - 1; j++) {

     

       74
       74
       +
                   if (memory.grid[i][j] != '?') continue;

     

       75
       75
       +
                   

     

       76
       76
       +
                   // Calculate cluster density (3x3 area)

     

       77
       77
       +
                   int clusterDensity = 0;

     

       78
       78
       +
                   for (int di = -1; di <= 1; di++) {

     

       79
       79
       +
                       for (int dj = -1; dj <= 1; dj++) {

     

       80
       80
       +
                           clusterDensity += densityMap[i + di][j + dj];

     

       81
       81
       +
                       }

     

       82
       82
       +
                   }

     

       83
       83
       +
                   

     

       84
       84
       +
                   if (clusterDensity > maxDensity) {

     

       85
       85
       +
                       maxDensity = clusterDensity;

     

       86
       86
       +
                       *centerRow = i;

     

       87
       87
       +
                       *centerCol = j;

     

       88
       88
       +
                   }

     

       89
       89
       +
               }

     

       90
       90
       +
           }

     

       91
       91
       +
       }

     

       92
       92
       +
       

     

       93
       93
       +
       string smartMoveCluster(const ComputerMemory &memory) {

     

       94
       94
       +
           // Find new cluster if needed

     

       95
       95
       +
           if (clusterCenterRow == -1 || shotsInCurrentCluster >= maxShotsPerCluster) {

     

       96
       96
       +
               findBestCluster(&clusterCenterRow, &clusterCenterCol, memory);

     

       97
       97
       +
               shotsInCurrentCluster = 0;

     

       98
       98
       +
               

     

       99
       99
       +
               // No cluster found, pick any unknown cell

     

       100
       100
       +
               if (clusterCenterRow == -1) {

     

       101
       101
       +
                   for (int i = 0; i < BOARDSIZE; i++) {

     

       102
       102
       +
                       for (int j = 0; j < BOARDSIZE; j++) {

     

       103
       103
       +
                           if (memory.grid[i][j] == '?') {

     

       104
       104
       +
                               return formatMove(i, j);

     

       105
       105
       +
                           }

     

       106
       106
       +
                       }

     

       107
       107
       +
                   }

     

       108
       108
       +
                   return formatMove(rand() % BOARDSIZE, rand() % BOARDSIZE);

     

       109
       109
       +
               }

     

       110
       110
       +
           }

     

       111
       111
       +
           

     

       112
       112
       +
           // Shoot within current cluster

     

       113
       113
       +
           int attempts = 0;

     

       114
       114
       +
           while (attempts < 100) {

     

       115
       115
       +
               int offsetRow = (rand() % 5) - 2;

     

       116
       116
       +
               int offsetCol = (rand() % 5) - 2;

     

       117
       117
       +
               

     

       118
       118
       +
               int targetRow = clusterCenterRow + offsetRow;

     

       119
       119
       +
               int targetCol = clusterCenterCol + offsetCol;

     

       120
       120
       +
               

     

       121
       121
       +
               if (targetRow >= 0 && targetRow < BOARDSIZE && 

     

       122
       122
       +
                   targetCol >= 0 && targetCol < BOARDSIZE && 

     

       123
       123
       +
                   memory.grid[targetRow][targetCol] == '?') {

     

       124
       124
       +
                   

     

       125
       125
       +
                   shotsInCurrentCluster++;

     

       126
       126
       +
                   return formatMove(targetRow, targetCol);

     

       127
       127
       +
               }

     

       128
       128
       +
               attempts++;

     

       129
       129
       +
           }

     

       130
       130
       +
           

     

       131
       131
       +
           // Fallback

     

       132
       132
       +
           shotsInCurrentCluster++;

     

       133
       133
       +
           return formatMove(rand() % BOARDSIZE, rand() % BOARDSIZE);

     

       134
       134
       +
       }

+83

scripts/test-submissions/memory_functions_diagonal.cpp

···

       1
       1
       +
       #include "battleship.h"

     

       2
       2
       +
       #include "kasbs.h"

     

       3
       3
       +
       #include "memory.h"

     

       4
       4
       +
       #include <string>

     

       5
       5
       +
       

     

       6
       6
       +
       using namespace std;

     

       7
       7
       +
       

     

       8
       8
       +
       // Diagonal AI - shoots in diagonal patterns

     

       9
       9
       +
       void initMemoryDiagonal(ComputerMemory &memory) {

     

       10
       10
       +
          memory.mode        =  RANDOM;

     

       11
       11
       +
          memory.hitRow      = -1;

     

       12
       12
       +
          memory.hitCol      = -1;

     

       13
       13
       +
          memory.hitShip     =  NONE;

     

       14
       14
       +
          memory.fireDir     =  NONE;

     

       15
       15
       +
          memory.fireDist    =  1;

     

       16
       16
       +
          memory.lastResult  =  NONE;

     

       17
       17
       +
       

     

       18
       18
       +
          for (int i = 0; i < BOARDSIZE; i++) {

     

       19
       19
       +
             for (int j = 0; j < BOARDSIZE; j++) {

     

       20
       20
       +
                memory.grid[i][j] = EMPTY_MARKER;

     

       21
       21
       +
             }

     

       22
       22
       +
          }

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       string smartMoveDiagonal(const ComputerMemory &memory) {

     

       26
       26
       +
          if (memory.mode == RANDOM) {

     

       27
       27
       +
             // Shoot in diagonal pattern first

     

       28
       28
       +
             for (int i = 0; i < BOARDSIZE; i++) {

     

       29
       29
       +
                for (int j = 0; j < BOARDSIZE; j++) {

     

       30
       30
       +
                   if ((i + j) % 3 == 0 && memory.grid[i][j] == EMPTY_MARKER) {

     

       31
       31
       +
                      char letter = static_cast<char>('A' + i);

     

       32
       32
       +
                      return string(1, letter) + to_string(j + 1);

     

       33
       33
       +
                   }

     

       34
       34
       +
                }

     

       35
       35
       +
             }

     

       36
       36
       +
             

     

       37
       37
       +
             // Fallback to any empty cell

     

       38
       38
       +
             for (int i = 0; i < BOARDSIZE; i++) {

     

       39
       39
       +
                for (int j = 0; j < BOARDSIZE; j++) {

     

       40
       40
       +
                   if (memory.grid[i][j] == EMPTY_MARKER) {

     

       41
       41
       +
                      char letter = static_cast<char>('A' + i);

     

       42
       42
       +
                      return string(1, letter) + to_string(j + 1);

     

       43
       43
       +
                   }

     

       44
       44
       +
                }

     

       45
       45
       +
             }

     

       46
       46
       +
          }

     

       47
       47
       +
          

     

       48
       48
       +
          // Target mode - shoot adjacent cells

     

       49
       49
       +
          int directions[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};

     

       50
       50
       +
          for (int d = 0; d < 4; d++) {

     

       51
       51
       +
             int newRow = memory.hitRow + directions[d][0];

     

       52
       52
       +
             int newCol = memory.hitCol + directions[d][1];

     

       53
       53
       +
             

     

       54
       54
       +
             if (newRow >= 0 && newRow < BOARDSIZE && newCol >= 0 && newCol < BOARDSIZE &&

     

       55
       55
       +
                 memory.grid[newRow][newCol] == EMPTY_MARKER) {

     

       56
       56
       +
                char letter = static_cast<char>('A' + newRow);

     

       57
       57
       +
                return string(1, letter) + to_string(newCol + 1);

     

       58
       58
       +
             }

     

       59
       59
       +
          }

     

       60
       60
       +
          

     

       61
       61
       +
          return "A1";

     

       62
       62
       +
       }

     

       63
       63
       +
       

     

       64
       64
       +
       void updateMemoryDiagonal(int row, int col, int result, ComputerMemory &memory) {

     

       65
       65
       +
          memory.lastResult = result;

     

       66
       66
       +
          char marker;

     

       67
       67
       +
          if (isAMiss(result)) {

     

       68
       68
       +
             marker = MISS_MARKER;

     

       69
       69
       +
          } else {

     

       70
       70
       +
             marker = HIT_MARKER;

     

       71
       71
       +
          }

     

       72
       72
       +
          memory.grid[row][col] = marker;

     

       73
       73
       +
          

     

       74
       74
       +
          if (memory.mode == RANDOM && !isAMiss(result)) {

     

       75
       75
       +
             memory.mode = SEARCH;

     

       76
       76
       +
             memory.hitRow = row;

     

       77
       77
       +
             memory.hitCol = col;

     

       78
       78
       +
          } else if (isASunk(result)) {

     

       79
       79
       +
             memory.mode = RANDOM;

     

       80
       80
       +
             memory.hitRow = -1;

     

       81
       81
       +
             memory.hitCol = -1;

     

       82
       82
       +
          }

     

       83
       83
       +
       }

+108

scripts/test-submissions/memory_functions_edge.cpp

···

       1
       1
       +
       #include "battleship.h"

     

       2
       2
       +
       #include "kasbs.h"

     

       3
       3
       +
       #include "memory.h"

     

       4
       4
       +
       #include <string>

     

       5
       5
       +
       #include <cstdlib>

     

       6
       6
       +
       

     

       7
       7
       +
       using namespace std;

     

       8
       8
       +
       

     

       9
       9
       +
       // Edge AI - prioritizes edges and corners first

     

       10
       10
       +
       void initMemoryEdge(ComputerMemory &memory) {

     

       11
       11
       +
          memory.mode        =  RANDOM;

     

       12
       12
       +
          memory.hitRow      = -1;

     

       13
       13
       +
          memory.hitCol      = -1;

     

       14
       14
       +
          memory.hitShip     =  NONE;

     

       15
       15
       +
          memory.fireDir     =  NONE;

     

       16
       16
       +
          memory.fireDist    =  1;

     

       17
       17
       +
          memory.lastResult  =  NONE;

     

       18
       18
       +
       

     

       19
       19
       +
          for (int i = 0; i < BOARDSIZE; i++) {

     

       20
       20
       +
             for (int j = 0; j < BOARDSIZE; j++) {

     

       21
       21
       +
                memory.grid[i][j] = EMPTY_MARKER;

     

       22
       22
       +
             }

     

       23
       23
       +
          }

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       string smartMoveEdge(const ComputerMemory &memory) {

     

       27
       27
       +
          if (memory.mode == RANDOM) {

     

       28
       28
       +
             // First shoot corners

     

       29
       29
       +
             int corners[4][2] = {{0, 0}, {0, BOARDSIZE-1}, {BOARDSIZE-1, 0}, {BOARDSIZE-1, BOARDSIZE-1}};

     

       30
       30
       +
             for (int c = 0; c < 4; c++) {

     

       31
       31
       +
                int r = corners[c][0];

     

       32
       32
       +
                int col = corners[c][1];

     

       33
       33
       +
                if (memory.grid[r][col] == EMPTY_MARKER) {

     

       34
       34
       +
                   char letter = static_cast<char>('A' + r);

     

       35
       35
       +
                   return string(1, letter) + to_string(col + 1);

     

       36
       36
       +
                }

     

       37
       37
       +
             }

     

       38
       38
       +
             

     

       39
       39
       +
             // Then shoot edges

     

       40
       40
       +
             for (int i = 0; i < BOARDSIZE; i++) {

     

       41
       41
       +
                // Top edge

     

       42
       42
       +
                if (memory.grid[0][i] == EMPTY_MARKER) {

     

       43
       43
       +
                   return string(1, 'A') + to_string(i + 1);

     

       44
       44
       +
                }

     

       45
       45
       +
                // Bottom edge

     

       46
       46
       +
                if (memory.grid[BOARDSIZE-1][i] == EMPTY_MARKER) {

     

       47
       47
       +
                   char letter = static_cast<char>('A' + BOARDSIZE - 1);

     

       48
       48
       +
                   return string(1, letter) + to_string(i + 1);

     

       49
       49
       +
                }

     

       50
       50
       +
                // Left edge

     

       51
       51
       +
                if (memory.grid[i][0] == EMPTY_MARKER) {

     

       52
       52
       +
                   char letter = static_cast<char>('A' + i);

     

       53
       53
       +
                   return string(1, letter) + to_string(1);

     

       54
       54
       +
                }

     

       55
       55
       +
                // Right edge

     

       56
       56
       +
                if (memory.grid[i][BOARDSIZE-1] == EMPTY_MARKER) {

     

       57
       57
       +
                   char letter = static_cast<char>('A' + i);

     

       58
       58
       +
                   return string(1, letter) + to_string(BOARDSIZE);

     

       59
       59
       +
                }

     

       60
       60
       +
             }

     

       61
       61
       +
             

     

       62
       62
       +
             // Then fill in the rest

     

       63
       63
       +
             for (int i = 0; i < BOARDSIZE; i++) {

     

       64
       64
       +
                for (int j = 0; j < BOARDSIZE; j++) {

     

       65
       65
       +
                   if (memory.grid[i][j] == EMPTY_MARKER) {

     

       66
       66
       +
                      char letter = static_cast<char>('A' + i);

     

       67
       67
       +
                      return string(1, letter) + to_string(j + 1);

     

       68
       68
       +
                   }

     

       69
       69
       +
                }

     

       70
       70
       +
             }

     

       71
       71
       +
          }

     

       72
       72
       +
          

     

       73
       73
       +
          // Target mode

     

       74
       74
       +
          int directions[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};

     

       75
       75
       +
          for (int d = 0; d < 4; d++) {

     

       76
       76
       +
             int newRow = memory.hitRow + directions[d][0];

     

       77
       77
       +
             int newCol = memory.hitCol + directions[d][1];

     

       78
       78
       +
             

     

       79
       79
       +
             if (newRow >= 0 && newRow < BOARDSIZE && newCol >= 0 && newCol < BOARDSIZE &&

     

       80
       80
       +
                 memory.grid[newRow][newCol] == EMPTY_MARKER) {

     

       81
       81
       +
                char letter = static_cast<char>('A' + newRow);

     

       82
       82
       +
                return string(1, letter) + to_string(newCol + 1);

     

       83
       83
       +
             }

     

       84
       84
       +
          }

     

       85
       85
       +
          

     

       86
       86
       +
          return "A1";

     

       87
       87
       +
       }

     

       88
       88
       +
       

     

       89
       89
       +
       void updateMemoryEdge(int row, int col, int result, ComputerMemory &memory) {

     

       90
       90
       +
          memory.lastResult = result;

     

       91
       91
       +
          char marker;

     

       92
       92
       +
          if (isAMiss(result)) {

     

       93
       93
       +
             marker = MISS_MARKER;

     

       94
       94
       +
          } else {

     

       95
       95
       +
             marker = HIT_MARKER;

     

       96
       96
       +
          }

     

       97
       97
       +
          memory.grid[row][col] = marker;

     

       98
       98
       +
          

     

       99
       99
       +
          if (memory.mode == RANDOM && !isAMiss(result)) {

     

       100
       100
       +
             memory.mode = SEARCH;

     

       101
       101
       +
             memory.hitRow = row;

     

       102
       102
       +
             memory.hitCol = col;

     

       103
       103
       +
          } else if (isASunk(result)) {

     

       104
       104
       +
             memory.mode = RANDOM;

     

       105
       105
       +
             memory.hitRow = -1;

     

       106
       106
       +
             memory.hitCol = -1;

     

       107
       107
       +
          }

     

       108
       108
       +
       }

+114

scripts/test-submissions/memory_functions_parity.cpp

···

       1
       1
       +
       // Parity AI - uses checkerboard with hunt/target mode

     

       2
       2
       +
       // Strategy: Efficient coverage with smart follow-up on hits

     

       3
       3
       +
       

     

       4
       4
       +
       #include "memory_functions_parity.h"

     

       5
       5
       +
       #include "battleship.h"

     

       6
       6
       +
       #include "kasbs.h"

     

       7
       7
       +
       #include "memory.h"

     

       8
       8
       +
       #include <string>

     

       9
       9
       +
       #include <vector>

     

       10
       10
       +
       #include <cstdlib>

     

       11
       11
       +
       #include <ctime>

     

       12
       12
       +
       

     

       13
       13
       +
       using namespace std;

     

       14
       14
       +
       

     

       15
       15
       +
       struct Cell {

     

       16
       16
       +
           int row;

     

       17
       17
       +
           int col;

     

       18
       18
       +
       };

     

       19
       19
       +
       

     

       20
       20
       +
       static vector<Cell> targetStack;

     

       21
       21
       +
       static bool huntMode = true;

     

       22
       22
       +
       static int currentRow = 0;

     

       23
       23
       +
       static int currentCol = 0;

     

       24
       24
       +
       

     

       25
       25
       +
       inline string formatMove(int row, int col) {

     

       26
       26
       +
           char letter = static_cast<char>('A' + row);

     

       27
       27
       +
           return string(1, letter) + to_string(col + 1);

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       void initMemoryParity(ComputerMemory &memory) {

     

       31
       31
       +
           srand(time(NULL));

     

       32
       32
       +
           

     

       33
       33
       +
           for (int i = 0; i < BOARDSIZE; i++) {

     

       34
       34
       +
               for (int j = 0; j < BOARDSIZE; j++) {

     

       35
       35
       +
                   memory.grid[i][j] = '?';

     

       36
       36
       +
               }

     

       37
       37
       +
           }

     

       38
       38
       +
           

     

       39
       39
       +
           targetStack.clear();

     

       40
       40
       +
           huntMode = true;

     

       41
       41
       +
           currentRow = 0;

     

       42
       42
       +
           currentCol = 0;

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       45
       45
       +
       void updateMemoryParity(int row, int col, int result, ComputerMemory &memory) {

     

       46
       46
       +
           if (result == HIT || result == SUNK) {

     

       47
       47
       +
               memory.grid[row][col] = 'h';

     

       48
       48
       +
               huntMode = false;

     

       49
       49
       +
               

     

       50
       50
       +
               // Add adjacent cells to target stack

     

       51
       51
       +
               int directions[4][2] = {{-1,0}, {1,0}, {0,-1}, {0,1}};

     

       52
       52
       +
               for (int i = 0; i < 4; i++) {

     

       53
       53
       +
                   int newRow = row + directions[i][0];

     

       54
       54
       +
                   int newCol = col + directions[i][1];

     

       55
       55
       +
                   

     

       56
       56
       +
                   if (newRow >= 0 && newRow < BOARDSIZE && 

     

       57
       57
       +
                       newCol >= 0 && newCol < BOARDSIZE && 

     

       58
       58
       +
                       memory.grid[newRow][newCol] == '?') {

     

       59
       59
       +
                       

     

       60
       60
       +
                       Cell cell = {newRow, newCol};

     

       61
       61
       +
                       targetStack.push_back(cell);

     

       62
       62
       +
                   }

     

       63
       63
       +
               }

     

       64
       64
       +
           } else {

     

       65
       65
       +
               memory.grid[row][col] = 'm';

     

       66
       66
       +
           }

     

       67
       67
       +
           

     

       68
       68
       +
           if (targetStack.empty()) {

     

       69
       69
       +
               huntMode = true;

     

       70
       70
       +
           }

     

       71
       71
       +
       }

     

       72
       72
       +
       

     

       73
       73
       +
       string smartMoveParity(const ComputerMemory &memory) {

     

       74
       74
       +
           // Target mode - shoot from stack

     

       75
       75
       +
           if (!huntMode && !targetStack.empty()) {

     

       76
       76
       +
               Cell target = targetStack.back();

     

       77
       77
       +
               targetStack.pop_back();

     

       78
       78
       +
               return formatMove(target.row, target.col);

     

       79
       79
       +
           }

     

       80
       80
       +
           

     

       81
       81
       +
           // Hunt mode - checkerboard pattern

     

       82
       82
       +
           while (true) {

     

       83
       83
       +
               if (currentRow >= BOARDSIZE) {

     

       84
       84
       +
                   // Try any unknown cell

     

       85
       85
       +
                   for (int i = 0; i < BOARDSIZE; i++) {

     

       86
       86
       +
                       for (int j = 0; j < BOARDSIZE; j++) {

     

       87
       87
       +
                           if (memory.grid[i][j] == '?') {

     

       88
       88
       +
                               return formatMove(i, j);

     

       89
       89
       +
                           }

     

       90
       90
       +
                       }

     

       91
       91
       +
                   }

     

       92
       92
       +
                   return formatMove(rand() % BOARDSIZE, rand() % BOARDSIZE);

     

       93
       93
       +
               }

     

       94
       94
       +
               

     

       95
       95
       +
               // Check parity and unknown

     

       96
       96
       +
               if ((currentRow + currentCol) % 2 == 0 && memory.grid[currentRow][currentCol] == '?') {

     

       97
       97
       +
                   int row = currentRow;

     

       98
       98
       +
                   int col = currentCol;

     

       99
       99
       +
                   

     

       100
       100
       +
                   currentCol++;

     

       101
       101
       +
                   if (currentCol >= BOARDSIZE) {

     

       102
       102
       +
                       currentCol = 0;

     

       103
       103
       +
                       currentRow++;

     

       104
       104
       +
                   }

     

       105
       105
       +
                   return formatMove(row, col);

     

       106
       106
       +
               }

     

       107
       107
       +
               

     

       108
       108
       +
               currentCol++;

     

       109
       109
       +
               if (currentCol >= BOARDSIZE) {

     

       110
       110
       +
                   currentCol = 0;

     

       111
       111
       +
                   currentRow++;

     

       112
       112
       +
               }

     

       113
       113
       +
           }

     

       114
       114
       +
       }

+126

scripts/test-submissions/memory_functions_probability.cpp

···

       1
       1
       +
       // Probability AI - calculates ship placement likelihood for each cell

     

       2
       2
       +
       // Strategy: Smart probability-based targeting with density analysis

     

       3
       3
       +
       

     

       4
       4
       +
       #include "memory_functions_probability.h"

     

       5
       5
       +
       #include "battleship.h"

     

       6
       6
       +
       #include "kasbs.h"

     

       7
       7
       +
       #include "memory.h"

     

       8
       8
       +
       #include <string>

     

       9
       9
       +
       #include <cstdlib>

     

       10
       10
       +
       #include <ctime>

     

       11
       11
       +
       

     

       12
       12
       +
       using namespace std;

     

       13
       13
       +
       

     

       14
       14
       +
       static int shipSizes[] = {5, 4, 3, 3, 2};

     

       15
       15
       +
       static int numShips = 5;

     

       16
       16
       +
       

     

       17
       17
       +
       inline string formatMove(int row, int col) {

     

       18
       18
       +
           char letter = static_cast<char>('A' + row);

     

       19
       19
       +
           return string(1, letter) + to_string(col + 1);

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       void initMemoryProbability(ComputerMemory &memory) {

     

       23
       23
       +
           srand(time(NULL));

     

       24
       24
       +
           

     

       25
       25
       +
           for (int i = 0; i < BOARDSIZE; i++) {

     

       26
       26
       +
               for (int j = 0; j < BOARDSIZE; j++) {

     

       27
       27
       +
                   memory.grid[i][j] = '?';

     

       28
       28
       +
               }

     

       29
       29
       +
           }

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       void updateMemoryProbability(int row, int col, int result, ComputerMemory &memory) {

     

       33
       33
       +
           if (result == HIT || result == SUNK) {

     

       34
       34
       +
               memory.grid[row][col] = 'h';

     

       35
       35
       +
           } else {

     

       36
       36
       +
               memory.grid[row][col] = 'm';

     

       37
       37
       +
           }

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       int calculateProbability(int row, int col, const ComputerMemory &memory) {

     

       41
       41
       +
           if (memory.grid[row][col] != '?') {

     

       42
       42
       +
               return 0;

     

       43
       43
       +
           }

     

       44
       44
       +
           

     

       45
       45
       +
           int probability = 0;

     

       46
       46
       +
           

     

       47
       47
       +
           // For each ship size

     

       48
       48
       +
           for (int ship = 0; ship < numShips; ship++) {

     

       49
       49
       +
               int size = shipSizes[ship];

     

       50
       50
       +
               

     

       51
       51
       +
               // Check horizontal placements

     

       52
       52
       +
               for (int startCol = col - size + 1; startCol <= col; startCol++) {

     

       53
       53
       +
                   if (startCol < 0 || startCol + size > BOARDSIZE) continue;

     

       54
       54
       +
                   

     

       55
       55
       +
                   bool valid = true;

     

       56
       56
       +
                   for (int c = startCol; c < startCol + size; c++) {

     

       57
       57
       +
                       if (memory.grid[row][c] == 'm' || memory.grid[row][c] == 's') {

     

       58
       58
       +
                           valid = false;

     

       59
       59
       +
                           break;

     

       60
       60
       +
                       }

     

       61
       61
       +
                   }

     

       62
       62
       +
                   if (valid) probability++;

     

       63
       63
       +
               }

     

       64
       64
       +
               

     

       65
       65
       +
               // Check vertical placements

     

       66
       66
       +
               for (int startRow = row - size + 1; startRow <= row; startRow++) {

     

       67
       67
       +
                   if (startRow < 0 || startRow + size > BOARDSIZE) continue;

     

       68
       68
       +
                   

     

       69
       69
       +
                   bool valid = true;

     

       70
       70
       +
                   for (int r = startRow; r < startRow + size; r++) {

     

       71
       71
       +
                       if (memory.grid[r][col] == 'm' || memory.grid[r][col] == 's') {

     

       72
       72
       +
                           valid = false;

     

       73
       73
       +
                           break;

     

       74
       74
       +
                       }

     

       75
       75
       +
                   }

     

       76
       76
       +
                   if (valid) probability++;

     

       77
       77
       +
               }

     

       78
       78
       +
           }

     

       79
       79
       +
           

     

       80
       80
       +
           // Bonus for cells adjacent to hits

     

       81
       81
       +
           int directions[4][2] = {{-1,0}, {1,0}, {0,-1}, {0,1}};

     

       82
       82
       +
           for (int i = 0; i < 4; i++) {

     

       83
       83
       +
               int newRow = row + directions[i][0];

     

       84
       84
       +
               int newCol = col + directions[i][1];

     

       85
       85
       +
               

     

       86
       86
       +
               if (newRow >= 0 && newRow < BOARDSIZE && 

     

       87
       87
       +
                   newCol >= 0 && newCol < BOARDSIZE && 

     

       88
       88
       +
                   memory.grid[newRow][newCol] == 'h') {

     

       89
       89
       +
                   probability += 50;

     

       90
       90
       +
               }

     

       91
       91
       +
           }

     

       92
       92
       +
           

     

       93
       93
       +
           return probability;

     

       94
       94
       +
       }

     

       95
       95
       +
       

     

       96
       96
       +
       string smartMoveProbability(const ComputerMemory &memory) {

     

       97
       97
       +
           int maxProb = -1;

     

       98
       98
       +
           int bestRow = 0, bestCol = 0;

     

       99
       99
       +
           

     

       100
       100
       +
           // Calculate probability for each cell

     

       101
       101
       +
           for (int i = 0; i < BOARDSIZE; i++) {

     

       102
       102
       +
               for (int j = 0; j < BOARDSIZE; j++) {

     

       103
       103
       +
                   int prob = calculateProbability(i, j, memory);

     

       104
       104
       +
                   if (prob > maxProb) {

     

       105
       105
       +
                       maxProb = prob;

     

       106
       106
       +
                       bestRow = i;

     

       107
       107
       +
                       bestCol = j;

     

       108
       108
       +
                   }

     

       109
       109
       +
               }

     

       110
       110
       +
           }

     

       111
       111
       +
           

     

       112
       112
       +
           // Fallback to random if needed

     

       113
       113
       +
           if (maxProb <= 0) {

     

       114
       114
       +
               for (int i = 0; i < BOARDSIZE; i++) {

     

       115
       115
       +
                   for (int j = 0; j < BOARDSIZE; j++) {

     

       116
       116
       +
                       if (memory.grid[i][j] == '?') {

     

       117
       117
       +
                           return formatMove(i, j);

     

       118
       118
       +
                       }

     

       119
       119
       +
                   }

     

       120
       120
       +
               }

     

       121
       121
       +
               bestRow = rand() % BOARDSIZE;

     

       122
       122
       +
               bestCol = rand() % BOARDSIZE;

     

       123
       123
       +
           }

     

       124
       124
       +
           

     

       125
       125
       +
           return formatMove(bestRow, bestCol);

     

       126
       126
       +
       }

+134

scripts/test-submissions/memory_functions_snake.cpp

···

       1
       1
       +
       // Snake AI - follows a snake/zigzag pattern across the board

     

       2
       2
       +
       // Strategy: Systematic coverage with no gaps, spacing based on smallest ship

     

       3
       3
       +
       

     

       4
       4
       +
       #include "memory_functions_snake.h"

     

       5
       5
       +
       #include "battleship.h"

     

       6
       6
       +
       #include "kasbs.h"

     

       7
       7
       +
       #include "memory.h"

     

       8
       8
       +
       #include <string>

     

       9
       9
       +
       #include <vector>

     

       10
       10
       +
       #include <cstdlib>

     

       11
       11
       +
       #include <ctime>

     

       12
       12
       +
       

     

       13
       13
       +
       using namespace std;

     

       14
       14
       +
       

     

       15
       15
       +
       struct Cell {

     

       16
       16
       +
           int row;

     

       17
       17
       +
           int col;

     

       18
       18
       +
       };

     

       19
       19
       +
       

     

       20
       20
       +
       static vector<Cell> targetStack;

     

       21
       21
       +
       static int currentRow = 0;

     

       22
       22
       +
       static int currentCol = 0;

     

       23
       23
       +
       static bool movingRight = true;

     

       24
       24
       +
       static const int spacing = 2;

     

       25
       25
       +
       

     

       26
       26
       +
       inline string formatMove(int row, int col) {

     

       27
       27
       +
           char letter = static_cast<char>('A' + row);

     

       28
       28
       +
           return string(1, letter) + to_string(col + 1);

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       void initMemorySnake(ComputerMemory &memory) {

     

       32
       32
       +
           srand(time(NULL));

     

       33
       33
       +
           

     

       34
       34
       +
           for (int i = 0; i < BOARDSIZE; i++) {

     

       35
       35
       +
               for (int j = 0; j < BOARDSIZE; j++) {

     

       36
       36
       +
                   memory.grid[i][j] = '?';

     

       37
       37
       +
               }

     

       38
       38
       +
           }

     

       39
       39
       +
           

     

       40
       40
       +
           targetStack.clear();

     

       41
       41
       +
           currentRow = 0;

     

       42
       42
       +
           currentCol = 0;

     

       43
       43
       +
           movingRight = true;

     

       44
       44
       +
       }

     

       45
       45
       +
       

     

       46
       46
       +
       void updateMemorySnake(int row, int col, int result, ComputerMemory &memory) {

     

       47
       47
       +
           if (result == HIT || result == SUNK) {

     

       48
       48
       +
               memory.grid[row][col] = 'h';

     

       49
       49
       +
               

     

       50
       50
       +
               // Add adjacent cells to target stack

     

       51
       51
       +
               int directions[4][2] = {{-1,0}, {1,0}, {0,-1}, {0,1}};

     

       52
       52
       +
               for (int i = 0; i < 4; i++) {

     

       53
       53
       +
                   int newRow = row + directions[i][0];

     

       54
       54
       +
                   int newCol = col + directions[i][1];

     

       55
       55
       +
                   

     

       56
       56
       +
                   if (newRow >= 0 && newRow < BOARDSIZE && 

     

       57
       57
       +
                       newCol >= 0 && newCol < BOARDSIZE && 

     

       58
       58
       +
                       memory.grid[newRow][newCol] == '?') {

     

       59
       59
       +
                       

     

       60
       60
       +
                       Cell cell = {newRow, newCol};

     

       61
       61
       +
                       targetStack.push_back(cell);

     

       62
       62
       +
                   }

     

       63
       63
       +
               }

     

       64
       64
       +
           } else {

     

       65
       65
       +
               memory.grid[row][col] = 'm';

     

       66
       66
       +
           }

     

       67
       67
       +
       }

     

       68
       68
       +
       

     

       69
       69
       +
       void getNextSnakePosition(int* row, int* col, const ComputerMemory &memory) {

     

       70
       70
       +
           while (true) {

     

       71
       71
       +
               // Off board, move to next row

     

       72
       72
       +
               if (currentCol < 0 || currentCol >= BOARDSIZE) {

     

       73
       73
       +
                   currentRow += spacing;

     

       74
       74
       +
                   movingRight = !movingRight;

     

       75
       75
       +
                   

     

       76
       76
       +
                   if (movingRight) {

     

       77
       77
       +
                       currentCol = 0;

     

       78
       78
       +
                   } else {

     

       79
       79
       +
                       currentCol = BOARDSIZE - 1;

     

       80
       80
       +
                   }

     

       81
       81
       +
                   

     

       82
       82
       +
                   // Covered board, start filling gaps

     

       83
       83
       +
                   if (currentRow >= BOARDSIZE) {

     

       84
       84
       +
                       for (int i = 0; i < BOARDSIZE; i++) {

     

       85
       85
       +
                           for (int j = 0; j < BOARDSIZE; j++) {

     

       86
       86
       +
                               if (memory.grid[i][j] == '?') {

     

       87
       87
       +
                                   *row = i;

     

       88
       88
       +
                                   *col = j;

     

       89
       89
       +
                                   return;

     

       90
       90
       +
                               }

     

       91
       91
       +
                           }

     

       92
       92
       +
                       }

     

       93
       93
       +
                       *row = rand() % BOARDSIZE;

     

       94
       94
       +
                       *col = rand() % BOARDSIZE;

     

       95
       95
       +
                       return;

     

       96
       96
       +
                   }

     

       97
       97
       +
                   continue;

     

       98
       98
       +
               }

     

       99
       99
       +
               

     

       100
       100
       +
               // Current position valid

     

       101
       101
       +
               if (memory.grid[currentRow][currentCol] == '?') {

     

       102
       102
       +
                   *row = currentRow;

     

       103
       103
       +
                   *col = currentCol;

     

       104
       104
       +
                   

     

       105
       105
       +
                   if (movingRight) {

     

       106
       106
       +
                       currentCol += spacing;

     

       107
       107
       +
                   } else {

     

       108
       108
       +
                       currentCol -= spacing;

     

       109
       109
       +
                   }

     

       110
       110
       +
                   return;

     

       111
       111
       +
               }

     

       112
       112
       +
               

     

       113
       113
       +
               // Already shot, move on

     

       114
       114
       +
               if (movingRight) {

     

       115
       115
       +
                   currentCol += spacing;

     

       116
       116
       +
               } else {

     

       117
       117
       +
                   currentCol -= spacing;

     

       118
       118
       +
               }

     

       119
       119
       +
           }

     

       120
       120
       +
       }

     

       121
       121
       +
       

     

       122
       122
       +
       string smartMoveSnake(const ComputerMemory &memory) {

     

       123
       123
       +
           // Shoot targets from hits first

     

       124
       124
       +
           if (!targetStack.empty()) {

     

       125
       125
       +
               Cell target = targetStack.back();

     

       126
       126
       +
               targetStack.pop_back();

     

       127
       127
       +
               return formatMove(target.row, target.col);

     

       128
       128
       +
           }

     

       129
       129
       +
           

     

       130
       130
       +
           // Follow snake pattern

     

       131
       131
       +
           int row, col;

     

       132
       132
       +
           getNextSnakePosition(&row, &col, memory);

     

       133
       133
       +
           return formatMove(row, col);

     

       134
       134
       +
       }

+109

scripts/test-submissions/memory_functions_spiral.cpp

···

       1
       1
       +
       // Spiral AI - shoots in an inward spiral pattern

     

       2
       2
       +
       // Strategy: Methodical coverage starting from edges, spiraling toward center

     

       3
       3
       +
       

     

       4
       4
       +
       #include "memory_functions_spiral.h"

     

       5
       5
       +
       #include "battleship.h"

     

       6
       6
       +
       #include "kasbs.h"

     

       7
       7
       +
       #include "memory.h"

     

       8
       8
       +
       #include <string>

     

       9
       9
       +
       #include <cstdlib>

     

       10
       10
       +
       #include <ctime>

     

       11
       11
       +
       

     

       12
       12
       +
       using namespace std;

     

       13
       13
       +
       

     

       14
       14
       +
       struct SpiralState {

     

       15
       15
       +
           int nextRow;

     

       16
       16
       +
           int nextCol;

     

       17
       17
       +
           int spiralDepth;

     

       18
       18
       +
           int currentDirection; // 0=RIGHT, 1=DOWN, 2=LEFT, 3=UP

     

       19
       19
       +
           int stepsInCurrentDirection;

     

       20
       20
       +
           int stepsToTake;

     

       21
       21
       +
           bool initialized;

     

       22
       22
       +
       };

     

       23
       23
       +
       

     

       24
       24
       +
       static SpiralState state;

     

       25
       25
       +
       

     

       26
       26
       +
       inline string formatMove(int row, int col) {

     

       27
       27
       +
           char letter = static_cast<char>('A' + row);

     

       28
       28
       +
           return string(1, letter) + to_string(col + 1);

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       void initMemorySpiral(ComputerMemory &memory) {

     

       32
       32
       +
           srand(time(NULL));

     

       33
       33
       +
           

     

       34
       34
       +
           for (int i = 0; i < BOARDSIZE; i++) {

     

       35
       35
       +
               for (int j = 0; j < BOARDSIZE; j++) {

     

       36
       36
       +
                   memory.grid[i][j] = '?';

     

       37
       37
       +
               }

     

       38
       38
       +
           }

     

       39
       39
       +
           

     

       40
       40
       +
           state.nextRow = 0;

     

       41
       41
       +
           state.nextCol = 0;

     

       42
       42
       +
           state.currentDirection = 0; // RIGHT

     

       43
       43
       +
           state.spiralDepth = 0;

     

       44
       44
       +
           state.stepsInCurrentDirection = 0;

     

       45
       45
       +
           state.stepsToTake = BOARDSIZE - 1;

     

       46
       46
       +
           state.initialized = true;

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       void updateMemorySpiral(int row, int col, int result, ComputerMemory &memory) {

     

       50
       50
       +
           if (result == HIT || result == SUNK) {

     

       51
       51
       +
               memory.grid[row][col] = 'h';

     

       52
       52
       +
           } else {

     

       53
       53
       +
               memory.grid[row][col] = 'm';

     

       54
       54
       +
           }

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       57
       57
       +
       string smartMoveSpiral(const ComputerMemory &memory) {

     

       58
       58
       +
           if (!state.initialized) {

     

       59
       59
       +
               return formatMove(rand() % BOARDSIZE, rand() % BOARDSIZE);

     

       60
       60
       +
           }

     

       61
       61
       +
           

     

       62
       62
       +
           int row = state.nextRow;

     

       63
       63
       +
           int col = state.nextCol;

     

       64
       64
       +
           

     

       65
       65
       +
           // Advance to next position in spiral

     

       66
       66
       +
           state.stepsInCurrentDirection++;

     

       67
       67
       +
           

     

       68
       68
       +
           // Move in current direction

     

       69
       69
       +
           switch (state.currentDirection) {

     

       70
       70
       +
               case 0: // RIGHT

     

       71
       71
       +
                   state.nextCol++;

     

       72
       72
       +
                   break;

     

       73
       73
       +
               case 1: // DOWN

     

       74
       74
       +
                   state.nextRow++;

     

       75
       75
       +
                   break;

     

       76
       76
       +
               case 2: // LEFT

     

       77
       77
       +
                   state.nextCol--;

     

       78
       78
       +
                   break;

     

       79
       79
       +
               case 3: // UP

     

       80
       80
       +
                   state.nextRow--;

     

       81
       81
       +
                   break;

     

       82
       82
       +
           }

     

       83
       83
       +
           

     

       84
       84
       +
           // Check if we need to turn

     

       85
       85
       +
           if (state.stepsInCurrentDirection >= state.stepsToTake) {

     

       86
       86
       +
               state.stepsInCurrentDirection = 0;

     

       87
       87
       +
               state.currentDirection = (state.currentDirection + 1) % 4;

     

       88
       88
       +
               

     

       89
       89
       +
               // After turning twice, reduce steps

     

       90
       90
       +
               if (state.currentDirection == 0 || state.currentDirection == 2) {

     

       91
       91
       +
                   state.stepsToTake--;

     

       92
       92
       +
                   state.spiralDepth++;

     

       93
       93
       +
               }

     

       94
       94
       +
           }

     

       95
       95
       +
           

     

       96
       96
       +
           // If spiraled to center, use fallback

     

       97
       97
       +
           if (state.spiralDepth >= BOARDSIZE / 2) {

     

       98
       98
       +
               for (int i = 0; i < BOARDSIZE; i++) {

     

       99
       99
       +
                   for (int j = 0; j < BOARDSIZE; j++) {

     

       100
       100
       +
                       if (memory.grid[i][j] == '?') {

     

       101
       101
       +
                           return formatMove(i, j);

     

       102
       102
       +
                       }

     

       103
       103
       +
                   }

     

       104
       104
       +
               }

     

       105
       105
       +
               return formatMove(rand() % BOARDSIZE, rand() % BOARDSIZE);

     

       106
       106
       +
           }

     

       107
       107
       +
           

     

       108
       108
       +
           return formatMove(row, col);

     

       109
       109
       +
       }

+34 -49

scripts/test-upload.sh

···

       1
       1
        
       #!/bin/bash

     

       2
       2
        
       

     

       3
       3
       -
       # Test script to upload three different AI submissions

     

       3
       3
       +
       # Test script to upload all AI submissions

     

       4
       4
        
       

     

       5
       5
        
       HOST="0.0.0.0"

     

       6
       6
        
       PORT="2222"

     
···

       10
       10
        
       echo "=============================================="

     

       11
       11
        
       echo ""

     

       12
       12
        
       

     

       13
       13
       -
       # Copy klukas submission to test-submissions if it doesn't exist

     

       14
       14
       -
       if [ ! -f "$SCRIPT_DIR/test-submissions/memory_functions_klukas.cpp" ]; then

     

       15
       15
       -
           echo "Copying klukas submission..."

     

       16
       16
       -
           mkdir -p "$SCRIPT_DIR/test-submissions"

     

       17
       17
       -
           cp /Users/kierank/code/school/cs1210-battleship/src/memory_functions_klukas.cpp "$SCRIPT_DIR/test-submissions/"

     

       18
       18
       -
       fi

     

       13
       13
       +
       # Define all submissions: username, filename

     

       14
       14
       +
       declare -a SUBMISSIONS=(

     

       15
       15
       +
           "alice:memory_functions_random.cpp"

     

       16
       16
       +
           "bob:memory_functions_hunter.cpp"

     

       17
       17
       +
           "charlie:memory_functions_klukas.cpp"

     

       18
       18
       +
           "dave:memory_functions_diagonal.cpp"

     

       19
       19
       +
           "eve:memory_functions_edge.cpp"

     

       20
       20
       +
           "frank:memory_functions_spiral.cpp"

     

       21
       21
       +
           "grace:memory_functions_parity.cpp"

     

       22
       22
       +
           "henry:memory_functions_probability.cpp"

     

       23
       23
       +
           "iris:memory_functions_cluster.cpp"

     

       24
       24
       +
           "jack:memory_functions_snake.cpp"

     

       25
       25
       +
       )

     

       19
       26
        
       

     

       20
       20
       -
       # Upload for alice (random AI)

     

       21
       21
       -
       echo "📤 Uploading for user: alice"

     

       22
       22
       -
       echo "   File: test-submissions/memory_functions_random.cpp"

     

       23
       23
       -
       if [ -f "$SCRIPT_DIR/test-submissions/memory_functions_random.cpp" ]; then

     

       24
       24
       -
           scp -P $PORT "$SCRIPT_DIR/test-submissions/memory_functions_random.cpp" "alice@$HOST:~/memory_functions_random.cpp"

     

       25
       25
       -
           if [ $? -eq 0 ]; then

     

       26
       26
       -
               echo "✅ Upload successful for alice"

     

       27
       27
       +
       # Upload each submission

     

       28
       28
       +
       for submission in "${SUBMISSIONS[@]}"; do

     

       29
       29
       +
           IFS=':' read -r username filename <<< "$submission"

     

       30
       30
       +
           

     

       31
       31
       +
           echo "📤 Uploading for user: $username"

     

       32
       32
       +
           echo "   File: test-submissions/$filename"

     

       33
       33
       +
           

     

       34
       34
       +
           if [ -f "$SCRIPT_DIR/test-submissions/$filename" ]; then

     

       35
       35
       +
               # Capture SCP output to check for 100% completion

     

       36
       36
       +
               scp_output=$(scp -P $PORT "$SCRIPT_DIR/test-submissions/$filename" "$username@$HOST:~/$filename" 2>&1)

     

       37
       37
       +
               echo "$scp_output" | grep -q "100%"

     

       38
       38
       +
               if [ $? -eq 0 ]; then

     

       39
       39
       +
                   echo "✅ Upload successful for $username"

     

       40
       40
       +
               else

     

       41
       41
       +
                   echo "❌ Upload failed for $username"

     

       42
       42
       +
                   echo "$scp_output"

     

       43
       43
       +
               fi

     

       27
       44
        
           else

     

       28
       28
       -
               echo "❌ Upload failed for alice"

     

       45
       45
       +
               echo "❌ Error: File not found"

     

       29
       46
        
           fi

     

       30
       30
       -
       else

     

       31
       31
       -
           echo "❌ Error: File not found"

     

       32
       32
       -
       fi

     

       33
       33
       -
       echo ""

     

       34
       34
       -
       

     

       35
       35
       -
       # Upload for bob (hunter AI)

     

       36
       36
       -
       echo "📤 Uploading for user: bob"

     

       37
       37
       -
       echo "   File: test-submissions/memory_functions_hunter.cpp"

     

       38
       38
       -
       if [ -f "$SCRIPT_DIR/test-submissions/memory_functions_hunter.cpp" ]; then

     

       39
       39
       -
           scp -P $PORT "$SCRIPT_DIR/test-submissions/memory_functions_hunter.cpp" "bob@$HOST:~/memory_functions_hunter.cpp"

     

       40
       40
       -
           if [ $? -eq 0 ]; then

     

       41
       41
       -
               echo "✅ Upload successful for bob"

     

       42
       42
       -
           else

     

       43
       43
       -
               echo "❌ Upload failed for bob"

     

       44
       44
       -
           fi

     

       45
       45
       -
       else

     

       46
       46
       -
           echo "❌ Error: File not found"

     

       47
       47
       -
       fi

     

       48
       48
       -
       echo ""

     

       49
       49
       -
       

     

       50
       50
       -
       # Upload for charlie (klukas AI)

     

       51
       51
       -
       echo "📤 Uploading for user: charlie"

     

       52
       52
       -
       echo "   File: test-submissions/memory_functions_klukas.cpp"

     

       53
       53
       -
       if [ -f "$SCRIPT_DIR/test-submissions/memory_functions_klukas.cpp" ]; then

     

       54
       54
       -
           scp -P $PORT "$SCRIPT_DIR/test-submissions/memory_functions_klukas.cpp" "charlie@$HOST:~/memory_functions_klukas.cpp"

     

       55
       55
       -
           if [ $? -eq 0 ]; then

     

       56
       56
       -
               echo "✅ Upload successful for charlie"

     

       57
       57
       -
           else

     

       58
       58
       -
               echo "❌ Upload failed for charlie"

     

       59
       59
       -
           fi

     

       60
       60
       -
       else

     

       61
       61
       -
           echo "❌ Error: File not found"

     

       62
       62
       -
       fi

     

       63
       63
       -
       echo ""

     

       47
       47
       +
           echo ""

     

       48
       48
       +
       done

     

       64
       49
        
       

     

       65
       50
        
       echo "=============================================="

     

       66
       51
        
       echo "✨ All submissions uploaded!"

static/brackets-viewer.min.css

···

       1
       1
       +
       .brackets-viewer{--primary-background: #fff;--secondary-background: #eceff1;--match-background: var(--primary-background);--font-color: #212529;--win-color: #50b649;--loss-color: #e61a1a;--label-color: grey;--hint-color: #a7a7a7;--connector-color: #9e9e9e;--border-color: #d9d9d9;--border-hover-color: #b6b5b5;--border-selected-color: rgb(60, 60, 60);--text-size: 12px;--round-margin: 40px;--match-width: 150px;--match-horizontal-padding: 8px;--match-vertical-padding: 6px;--connector-border-width: 2px;--match-border-width: 1px;--match-border-radius: 0.3em;--participant-image-size: 1em}.brackets-viewer{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";background:var(--primary-background);color:var(--font-color);font-size:var(--text-size);text-align:left;display:flex;flex-direction:column;align-items:flex-start;overflow:auto;-webkit-user-select:none;-moz-user-select:none;user-select:none;margin:0 auto;padding:10px 50px}.brackets-viewer:empty{display:none}.brackets-viewer *,.brackets-viewer ::after,.brackets-viewer ::before{box-sizing:border-box}.brackets-viewer h1,.brackets-viewer h2,.brackets-viewer h3{margin-bottom:.5em;font-weight:500;line-height:1.2}.brackets-viewer h1{font-size:2em;margin-top:30px;margin-bottom:20px}.brackets-viewer h2{font-size:1.7em}.brackets-viewer h3{text-align:center;background:var(--secondary-background);font-size:1.1em;padding:10px 0px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;width:var(--match-width)}.brackets-viewer .round-robin{display:flex;flex-wrap:wrap;justify-content:center;row-gap:24px}.brackets-viewer .round-robin h1{flex-basis:100%}.brackets-viewer .round-robin h2{text-align:center}.brackets-viewer .round-robin .group:not(:last-of-type){margin-right:var(--round-margin)}.brackets-viewer .round-robin .group h2{margin:0 0 25px 0}.brackets-viewer .round-robin .group table{font-size:1em;margin:30px 0 20px 0;color:#a7a7a7;border-collapse:collapse}.brackets-viewer .round-robin .group th{font-weight:normal;text-align:start;cursor:help;border-bottom:var(--match-border-width) solid var(--border-color)}.brackets-viewer .round-robin .group td.hover{background:var(--secondary-background)}.brackets-viewer .round-robin .group th,.brackets-viewer .round-robin .group td{padding:5px}.brackets-viewer .round-robin .group td:nth-of-type(2),.brackets-viewer .round-robin .group td:last-of-type{color:var(--font-color);font-weight:500}.brackets-viewer .round-robin .round{width:-moz-fit-content;width:fit-content;margin:0 auto}.brackets-viewer .bracket h2{font-size:1.5em;color:gray}.brackets-viewer .bracket .rounds{display:flex}.brackets-viewer .bracket .rounds:not(:last-of-type){margin-bottom:15px}.brackets-viewer .bracket .rounds .round{display:flex;flex-direction:column}.brackets-viewer .bracket .rounds .round:not(:last-of-type){margin-right:var(--round-margin)}.brackets-viewer .match{flex:1;display:flex;align-items:center;margin:10px 0;width:var(--match-width);position:relative}.brackets-viewer .match.connect-next::after{content:"";display:block;position:absolute;right:calc(-1 * var(--round-margin)/2);width:calc(var(--round-margin)/2);height:50%;border-right:var(--connector-border-width) solid var(--connector-color)}.brackets-viewer .match.connect-next:nth-of-type(odd)::after{top:50%;border-top:var(--connector-border-width) solid var(--connector-color)}.brackets-viewer .match.connect-next:nth-of-type(even)::after{top:0;border-bottom:var(--connector-border-width) solid var(--connector-color)}.brackets-viewer .match.connect-next.straight::after{width:var(--round-margin);right:calc(-1*var(--round-margin));top:0;border-bottom:var(--connector-border-width) solid var(--connector-color);border-top:unset;border-right:unset}.brackets-viewer .opponents{width:100%;position:relative;border:var(--match-border-width) solid var(--border-color);border-radius:var(--match-border-radius);background:var(--match-background)}.brackets-viewer .opponents:hover{border:1px solid var(--border-hover-color)}.brackets-viewer .opponents.popover-selected{border:1px solid var(--border-selected-color)}.brackets-viewer .opponents>span{position:absolute;top:-10px;font-size:.8em;padding:0 5px;color:var(--label-color);background:var(--primary-background);border-radius:3px}.brackets-viewer .opponents>span:nth-of-type(1){left:3px}.brackets-viewer .opponents>span:nth-of-type(2){right:3px}.brackets-viewer .opponents.connect-previous::before{content:"";display:block;position:absolute;left:calc(-1 * var(--round-margin)/2);width:calc(var(--round-margin)/2);height:50%;border-bottom:var(--connector-border-width) solid var(--connector-color)}.bracket:nth-of-type(2) .brackets-viewer .opponents.connect-previous .opponents.connect-previous.straight::before,.bracket:nth-of-type(1) .brackets-viewer .opponents.connect-previous .opponents.connect-previous.straight::after{border-left:unset;left:var(--round-margin);width:var(--round-margin)}.bracket:nth-of-type(1) .brackets-viewer .opponents.connect-previous.straight::before{content:unset}.bracket:nth-of-type(2) .brackets-viewer .opponents.connect-previous.straight::after{content:unset}.brackets-viewer .participant{display:flex;justify-content:space-between;padding:2px var(--match-horizontal-padding);background:var(--match-background)}.brackets-viewer .participant.hover{background:var(--secondary-background) !important}.brackets-viewer .participant:nth-of-type(1){border-bottom:none;border-top-left-radius:var(--match-border-radius);border-top-right-radius:var(--match-border-radius);padding-top:var(--match-vertical-padding)}.brackets-viewer .participant:nth-of-type(2){border-top:none;border-bottom-left-radius:var(--match-border-radius);border-bottom-right-radius:var(--match-border-radius);padding-bottom:var(--match-vertical-padding)}.brackets-viewer .participant .name{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;width:80%}.brackets-viewer .participant .name.hint{color:var(--hint-color)}.brackets-viewer .participant .name>img{width:var(--participant-image-size);height:var(--participant-image-size);margin-right:4px;-o-object-fit:cover;object-fit:cover;border-radius:4px;vertical-align:middle;position:relative;bottom:1px}.brackets-viewer .participant .name>span{color:var(--hint-color);font-size:.9em;font-weight:initial}.brackets-viewer .participant .result{margin-left:10px;width:15%;text-align:center}.brackets-viewer .participant.win .name{font-weight:bold}.brackets-viewer .participant.win .result{color:var(--win-color)}.brackets-viewer .participant.loss .result{color:var(--loss-color)}.brackets-viewer [popover]{padding:0 14px 10px 14px}.brackets-viewer [popover] h4{font-size:1.1em;margin-bottom:24px}.brackets-viewer [popover] .match:not(:last-of-type){margin-bottom:20px}

static/brackets-viewer.min.js

···

       1
       1
       +
       !function(){var t={7335:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.setupConnection=e.getFinalConnection=e.getBracketConnection=e.addParticipantImage=e.addParticipantOrigin=e.setupLoss=e.setupWin=e.setupBye=e.setupHint=e.createRankingHeaders=e.createCell=e.createRow=e.createTable=e.createResultContainer=e.createNameContainer=e.createParticipantContainer=e.createOpponentsContainer=e.createChildCountLabel=e.createMatchLabel=e.createMatchContainer=e.createRoundContainer=e.createRoundsContainer=e.createGroupContainer=e.createBracketContainer=e.createEliminationContainer=e.createRoundRobinContainer=e.createPopoverTitle=e.createTitle=void 0;const r=n(3886),o=n(1491);e.createTitle=function(t){const e=document.createElement("h1");return e.innerText=t,e},e.createPopoverTitle=function(t){const e=document.createElement("h4");return e.innerText=t,e},e.createRoundRobinContainer=function(t){const e=document.createElement("div");return e.classList.add("round-robin"),e.setAttribute("data-stage-id",t.toString()),e},e.createEliminationContainer=function(t){const e=document.createElement("div");return e.classList.add("elimination"),e.setAttribute("data-stage-id",t.toString()),e},e.createBracketContainer=function(t,e){const n=document.createElement("section");if(n.classList.add("bracket"),t&&n.setAttribute("data-group-id",t.toString()),e){const t=document.createElement("h2");t.innerText=e,n.append(t)}return n},e.createGroupContainer=function(t,e){const n=document.createElement("h2");n.innerText=e;const r=document.createElement("section");return r.classList.add("group"),r.setAttribute("data-group-id",t.toString()),r.append(n),r},e.createRoundsContainer=function(){const t=document.createElement("div");return t.classList.add("rounds"),t},e.createRoundContainer=function(t,e){const n=document.createElement("h3");n.innerText=e;const r=document.createElement("article");return r.classList.add("round"),r.setAttribute("data-round-id",t.toString()),r.append(n),r},e.createMatchContainer=function(t){const e=document.createElement("div");return e.classList.add("match"),t&&((0,r.isMatchGame)(t)?e.setAttribute("data-match-game-id",t.id.toString()):e.setAttribute("data-match-id",t.id.toString()),e.setAttribute("data-match-status",t.status.toString())),e},e.createMatchLabel=function(t,e,n){const r=document.createElement("span");return r.innerText=t||"",r.title=e,n&&r.addEventListener("click",n),r},e.createChildCountLabel=function(t,e){const n=document.createElement("span");return n.innerText=t,e&&n.addEventListener("click",e),n},e.createOpponentsContainer=function(t){const e=document.createElement("div");return e.classList.add("opponents"),t&&e.addEventListener("click",t),e},e.createParticipantContainer=function(t){const e=document.createElement("div");return e.classList.add("participant"),null!=t&&e.setAttribute("data-participant-id",t.toString()),e},e.createNameContainer=function(){const t=document.createElement("div");return t.classList.add("name"),t},e.createResultContainer=function(){const t=document.createElement("div");return t.classList.add("result"),t},e.createTable=function(){return document.createElement("table")},e.createRow=function(){return document.createElement("tr")},e.createCell=function(t){const e=document.createElement("td");return e.innerText=String(t),e},e.createRankingHeaders=function(t){const e=document.createElement("tr"),n=t[0];for(const t in n){const n=t,o=(0,r.rankingHeader)(n),i=document.createElement("th");i.innerText=o.text,i.setAttribute("title",o.tooltip),e.append(i)}return e},e.setupHint=function(t,e){t.classList.add("hint"),t.innerText=e,t.title=e},e.setupBye=function(t){t.innerText=(0,o.t)("common.bye"),t.classList.add("bye")},e.setupWin=function(t,e,n){n.result&&"win"===n.result&&(t.classList.add("win"),void 0===n.score&&(e.innerText=(0,o.t)("abbreviations.win")))},e.setupLoss=function(t,e,n){(n.result&&"loss"===n.result||n.forfeit)&&(t.classList.add("loss"),n.forfeit?e.innerText=(0,o.t)("abbreviations.forfeit"):void 0===n.score&&(e.innerText=(0,o.t)("abbreviations.loss")))},e.addParticipantOrigin=function(t,e,n){const r=document.createElement("span");"before"===n?(r.innerText=`${e} `,t.prepend(r)):"after"===n&&(r.innerText=` (${e})`,t.append(r))},e.addParticipantImage=function(t,e){const n=document.createElement("img");n.src=e,t.prepend(n)},e.getBracketConnection=function(t,e,n,r,o,i){var a,s,u;const c={connectPrevious:!1,connectNext:!1};return"loser_bracket"===o?(c.connectPrevious=e>1&&(e%2==1?"square":"straight"),c.connectNext=e<n&&(e%2==0?"square":"straight")):(c.connectPrevious=e>1&&"square",c.connectNext=e<n?"square":!!i&&"straight"),t||2!==e||(("single_bracket"===o||"winner_bracket"===o)&&void 0===(null===(a=r.opponent1)||void 0===a?void 0:a.position)&&void 0===(null===(s=r.opponent2)||void 0===s?void 0:s.position)&&(c.connectPrevious=!1),"loser_bracket"===o&&void 0===(null===(u=r.opponent2)||void 0===u?void 0:u.position)&&(c.connectPrevious=!1)),c},e.getFinalConnection=function(t,e,n){return{connectPrevious:"grand_final"===t&&1===e&&"straight",connectNext:2===n&&1===e&&"straight"}},e.setupConnection=function(t,e,n){n.connectPrevious&&t.classList.add("connect-previous"),n.connectNext&&e.classList.add("connect-next"),"straight"===n.connectPrevious&&t.classList.add("straight"),"straight"===n.connectNext&&e.classList.add("straight")}},3886:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.isMatchGame=e.isMatch=e.rankingHeader=e.isMajorRound=e.getOriginAbbreviation=e.completeWithBlankMatches=e.findRoot=e.sortBy=e.splitByWithLeftovers=e.splitBy=void 0;const r=n(1491);function o(t){return"child_count"in t}e.splitBy=function(t,e){const n={};for(const r of t){const t=r[e];n[t]||(n[t]=[]),n[t].push(r)}return Object.values(n)},e.splitByWithLeftovers=function(t,e){var n;const r={};for(const o of t){const t=null!==(n=o[e])&&void 0!==n?n:"-1";r[t]||(r[t]=[]),r[t].push(o)}const o=[...Object.entries(r).filter((([t])=>"-1"!==t)).map((([t,e])=>e))];return o[-1]=r[-1],o},e.sortBy=function(t,e){return[...t].sort(((t,n)=>t[e]-n[e]))},e.findRoot=function(t){const e=document.querySelectorAll(t||".brackets-viewer");if(0===e.length)throw Error("Root not found. You must have at least one root element.");if(e.length>1)throw Error("Multiple possible roots were found. Please use `config.selector` to choose a specific root.");const n=e[0];if(!n.classList.contains("brackets-viewer"))throw Error("The selected root must have a `.brackets-viewer` class.");return n},e.completeWithBlankMatches=function(t,e,n){if(!n)return{matches:e,fromToornament:!1};let r=[];return"single_bracket"!==t&&"winner_bracket"!==t||(r=n.map((t=>{var e,n;return[(null===(e=t.opponent1)||void 0===e?void 0:e.position)||null,(null===(n=t.opponent2)||void 0===n?void 0:n.position)||null]})).flat()),"loser_bracket"===t&&(r=n.map((t=>{var e;return(null===(e=t.opponent2)||void 0===e?void 0:e.position)||null}))),0===r.filter((t=>null!==t)).length?{matches:e,fromToornament:!1}:{matches:r.map((t=>t&&e.find((e=>e.number===t))||null)),fromToornament:!0}},e.getOriginAbbreviation=function(t,e,n,o){return n=n||-1,e&&"loser_bracket"===t&&1===n||"single_bracket"===t||"winner_bracket"===t&&1===n?(0,r.t)("abbreviations.seed"):"loser_bracket"===t&&n%2==0&&"opponent1"===o?(0,r.t)("abbreviations.position"):null},e.isMajorRound=function(t){return 1===t||t%2==0},e.rankingHeader=function(t){return(0,r.t)(`ranking.${t}`,{returnObjects:!0})},e.isMatch=o,e.isMatchGame=function(t){return!o(t)}},9820:function(t,e,n){"use strict";var r=this&&this.__createBinding||(Object.create?function(t,e,n,r){void 0===r&&(r=n);var o=Object.getOwnPropertyDescriptor(e,n);o&&!("get"in o?!e.__esModule:o.writable||o.configurable)||(o={enumerable:!0,get:function(){return e[n]}}),Object.defineProperty(t,r,o)}:function(t,e,n,r){void 0===r&&(r=n),t[r]=e[n]}),o=this&&this.__exportStar||function(t,e){for(var n in t)"default"===n||Object.prototype.hasOwnProperty.call(e,n)||r(e,t,n)};Object.defineProperty(e,"__esModule",{value:!0}),e.BracketsViewer=void 0;const i=n(2038),a=n(9037),s=n(825);Object.defineProperty(e,"BracketsViewer",{enumerable:!0,get:function(){return s.BracketsViewer}}),window.bracketsViewer=new s.BracketsViewer,window.inMemoryDatabase=new i.InMemoryDatabase,window.bracketsManager=new a.BracketsManager(window.inMemoryDatabase),o(n(1834),e)},1491:function(t,e,n){"use strict";var r=this&&this.__importDefault||function(t){return t&&t.__esModule?t:{default:t}};Object.defineProperty(e,"__esModule",{value:!0}),e.getLoserBracketRoundName=e.getWinnerBracketRoundName=e.getRoundName=e.getBracketName=e.getGroupName=e.getMatchStatus=e.getFinalMatchLabel=e.getMatchLabel=e.getFinalOriginHint=e.getOriginHint=e.toI18nKey=e.t=e.addLocale=e.locales=void 0;const o=r(n(6073)),i=r(n(13)),a=n(7021),s=n(3886),u=r(n(9583)),c=r(n(8159));function l(t,e){return o.default.t(t,e)}function d(t){return t.replace("_","-")}e.locales={en:u.default,fr:c.default},o.default.use(i.default).init({fallbackLng:"en",debug:!1,resources:{en:{translation:e.locales.en},fr:{translation:e.locales.fr}}}),e.addLocale=async function(t,e){o.default.addResourceBundle(t,"translation",e,!0,!0),await o.default.changeLanguage()},e.t=l,e.toI18nKey=d,e.getOriginHint=function(t,e,n,r){if(1===t){if("single_bracket"===r)return t=>l("origin-hint.seed",{position:t});if("winner_bracket"===r)return t=>l("origin-hint.seed",{position:t});if("loser_bracket"===r&&n)return t=>l("origin-hint.seed",{position:t})}if((0,s.isMajorRound)(t)&&"loser_bracket"===r){if(t===e-2)return t=>l("origin-hint.winner-bracket-semi-final",{position:t});if(t===e)return()=>l("origin-hint.winner-bracket-final");const r=Math.ceil((t+1)/2);return n?t=>l("origin-hint.winner-bracket",{round:r-1,position:t}):t=>l("origin-hint.winner-bracket",{round:r,position:t})}},e.getFinalOriginHint=function(t,e,n){return"single_elimination"===t?t=>l("origin-hint.consolation-final",{position:t}):"grand_final"===e?1===n?()=>l("origin-hint.grand-final"):void 0:t=>l(1===t?"origin-hint.double-elimination-consolation-final-opponent-1":"origin-hint.double-elimination-consolation-final-opponent-2")},e.getMatchLabel=function(t,e,n,r){if(void 0===e||void 0===n||void 0===r)return l("match-label.default",{matchNumber:t});const o=l("winner_bracket"===r?"match-label.winner-bracket":"loser_bracket"===r?"match-label.loser-bracket":"match-label.standard-bracket"),i=e===n-1,a=e===n;if("single_bracket"===r){if(i)return l("match-label.standard-bracket-semi-final",{matchNumber:t});if(a)return l("match-label.standard-bracket-final")}return i?l("match-label.double-elimination-semi-final",{matchPrefix:o,matchNumber:t}):a?l("match-label.double-elimination-final",{matchPrefix:o}):l("match-label.double-elimination",{matchPrefix:o,roundNumber:e,matchNumber:t})},e.getFinalMatchLabel=function(t,e,n){return"consolation_final"===t?l("match-label.consolation-final"):1===n?l("match-label.grand-final-single"):l("match-label.grand-final",{roundNumber:e})},e.getMatchStatus=function(t){switch(t){case a.Status.Locked:return l("match-status.locked");case a.Status.Waiting:return l("match-status.waiting");case a.Status.Ready:return l("match-status.ready");case a.Status.Running:return l("match-status.running");case a.Status.Completed:return l("match-status.completed");case a.Status.Archived:return l("match-status.archived");default:return"Unknown status"}},e.getGroupName=function(t){return l("common.group-name",{groupNumber:t})},e.getBracketName=function(t,e){switch(e){case"winner_bracket":case"loser_bracket":return l(`common.group-name-${d(e)}`,{stage:t});default:return}},e.getRoundName=function({roundNumber:t,roundCount:e},n){return t===e?n("common.round-name-final"):n("common.round-name",{roundNumber:t})},e.getWinnerBracketRoundName=function({roundNumber:t,roundCount:e},n){return t===e?n("common.round-name-winner-bracket-final"):n("common.round-name-winner-bracket",{roundNumber:t})},e.getLoserBracketRoundName=function({roundNumber:t,roundCount:e},n){return t===e?n("common.round-name-loser-bracket-final"):n("common.round-name-loser-bracket",{roundNumber:t})}},825:function(t,e,n){"use strict";var r=this&&this.__createBinding||(Object.create?function(t,e,n,r){void 0===r&&(r=n);var o=Object.getOwnPropertyDescriptor(e,n);o&&!("get"in o?!e.__esModule:o.writable||o.configurable)||(o={enumerable:!0,get:function(){return e[n]}}),Object.defineProperty(t,r,o)}:function(t,e,n,r){void 0===r&&(r=n),t[r]=e[n]}),o=this&&this.__setModuleDefault||(Object.create?function(t,e){Object.defineProperty(t,"default",{enumerable:!0,value:e})}:function(t,e){t.default=e}),i=this&&this.__importStar||function(t){if(t&&t.__esModule)return t;var e={};if(null!=t)for(var n in t)"default"!==n&&Object.prototype.hasOwnProperty.call(t,n)&&r(e,t,n);return o(e,t),e};Object.defineProperty(e,"__esModule",{value:!0}),e.BracketsViewer=void 0,n(1016);const a=n(7021),s=n(3886),u=i(n(7335)),c=i(n(1491)),l=n(9037);e.BracketsViewer=class{constructor(){this.participantRefs={},this.participants=[],this.participantImages=[],this.skipFirstRound=!1,this.alwaysConnectFirstRound=!1,this._onMatchClick=t=>{},this._onMatchLabelClick=t=>{}}getRoundName(t,e){var n,r;return(null===(r=(n=this.config).customRoundName)||void 0===r?void 0:r.call(n,t,c.t))||e(t,c.t)}set onMatchClicked(t){this._onMatchClick=t}async render(t,e){var n,r,o,i,a,u,c,l,d,p,f;if("string"==typeof t)throw Error("Using a CSS selector as the first argument is deprecated. Please look here: https://github.com/Drarig29/brackets-viewer.js");const h=document.createDocumentFragment();if(this.config={customRoundName:null==e?void 0:e.customRoundName,participantOriginPlacement:null!==(n=null==e?void 0:e.participantOriginPlacement)&&void 0!==n?n:"before",separatedChildCountLabel:null!==(r=null==e?void 0:e.separatedChildCountLabel)&&void 0!==r&&r,showSlotsOrigin:null===(o=null==e?void 0:e.showSlotsOrigin)||void 0===o||o,showLowerBracketSlotsOrigin:null===(i=null==e?void 0:e.showLowerBracketSlotsOrigin)||void 0===i||i,showPopoverOnMatchLabelClick:null===(a=null==e?void 0:e.showPopoverOnMatchLabelClick)||void 0===a||a,highlightParticipantOnHover:null===(u=null==e?void 0:e.highlightParticipantOnHover)||void 0===u||u,showRankingTable:null===(c=null==e?void 0:e.showRankingTable)||void 0===c||c,rankingFormula:null!==(l=null==e?void 0:e.rankingFormula)&&void 0!==l?l:t=>3*t.wins+1*t.draws+0*t.losses},(null==e?void 0:e.onMatchClick)&&(this._onMatchClick=e.onMatchClick),(null==e?void 0:e.onMatchLabelClick)&&(this._onMatchLabelClick=e.onMatchLabelClick),!(null===(d=t.stages)||void 0===d?void 0:d.length))throw Error("The `data.stages` array is either empty or undefined");if(!(null===(p=t.participants)||void 0===p?void 0:p.length))throw Error("The `data.participants` array is either empty or undefined");if(!(null===(f=t.matches)||void 0===f?void 0:f.length))throw Error("The `data.matches` array is either empty or undefined");this.participants=t.participants,t.participants.forEach((t=>this.participantRefs[t.id]=[])),this.popover=document.createElement("div"),this.popover.setAttribute("popover","auto"),this.popover.addEventListener("toggle",(t=>{"closed"===t.newState&&this.clearPreviousPopoverSelections()})),h.append(this.popover),t.stages.forEach((e=>this.renderStage(h,{...t,stages:[e],matches:t.matches.filter((t=>t.stage_id===e.id)).map((n=>({...n,metadata:{stageType:e.type,games:t.matchGames.filter((t=>t.parent_id===n.id))}})))})));const g=(0,s.findRoot)(null==e?void 0:e.selector);(null==e?void 0:e.clear)&&(g.innerHTML=""),g.append(h)}updateMatch(t){var e,n,r,o,i,a;const s=document.querySelector(`[data-match-id='${t.id}']`);if(!s)throw Error("Match not found.");s.setAttribute("data-match-status",t.status.toString());const u=s.querySelector(".participant:nth-of-type(1) .result");u&&(null===(e=t.opponent1)||void 0===e?void 0:e.score)&&(u.innerHTML=null===(r=null===(n=t.opponent1)||void 0===n?void 0:n.score)||void 0===r?void 0:r.toString());const c=s.querySelector(".participant:nth-of-type(2) .result");c&&(null===(o=t.opponent2)||void 0===o?void 0:o.score)&&(c.innerHTML=null===(a=null===(i=t.opponent2)||void 0===i?void 0:i.score)||void 0===a?void 0:a.toString())}setParticipantImages(t){this.participantImages=t}async addLocale(t,e){await c.addLocale(t,e)}renderStage(t,e){var n;const r=e.stages[0];if(!(null===(n=e.matches)||void 0===n?void 0:n.length))throw Error(`No matches found for stage ${r.id}`);const o=(0,s.splitByWithLeftovers)(e.matches,"group_id");switch(this.stage=r,this.skipFirstRound=r.settings.skipFirstRound||!1,r.type){case"round_robin":this.renderRoundRobin(t,r,o);break;case"single_elimination":case"double_elimination":this.renderElimination(t,r,o);break;default:throw Error(`Unknown bracket type: ${r.type}`)}this.renderConsolationMatches(t,r,o)}renderRoundRobin(t,e,n){const r=u.createRoundRobinContainer(e.id);r.append(u.createTitle(e.name));let o=1;for(const t of n){const e=t[0].group_id,n=u.createGroupContainer(e,c.getGroupName(o++)),i=(0,s.splitBy)(t,"round_id").map((t=>(0,s.sortBy)(t,"number")));let a=1;for(const t of i){const e=t[0].round_id,r=this.getRoundName({roundNumber:a,roundCount:0,groupType:c.toI18nKey("round_robin")},c.getRoundName),o=u.createRoundContainer(e,r);for(const e of t)o.append(this.createMatch(e,!0));n.append(o),a++}this.config.showRankingTable&&n.append(this.createRanking(t)),r.append(n)}t.append(r)}renderElimination(t,e,n){const r=u.createEliminationContainer(e.id);r.append(u.createTitle(e.name)),"single_elimination"===e.type?this.renderSingleElimination(r,n):this.renderDoubleElimination(r,n),t.append(r)}renderConsolationMatches(t,e,n){const r=n[-1];if(!(null==r?void 0:r.length))return;const o=u.createBracketContainer(void 0,c.t("common.consolation")),i=u.createRoundsContainer();let a=0;for(const t of r)i.append(this.createMatch({...t,metadata:{label:c.t("match-label.default",{matchNumber:++a}),stageType:e.type,games:[]}},!0));o.append(i),t.append(o)}renderSingleElimination(t,e){const n=(0,s.splitBy)(e[0],"round_id").map((t=>(0,s.sortBy)(t,"number"))),{hasFinal:r,connectFinal:o,finalMatches:i}=this.getFinalInfoSingleElimination(e);this.renderBracket(t,n,c.getRoundName,"single_bracket",o),r&&this.renderFinal(t,"consolation_final",i)}renderDoubleElimination(t,e){const n=void 0!==e[1],r=(0,s.splitBy)(e[0],"round_id").map((t=>(0,s.sortBy)(t,"number"))),{hasFinal:o,connectFinal:i,grandFinalMatches:a,consolationFinalMatches:u}=this.getFinalInfoDoubleElimination(e);if(this.renderBracket(t,r,c.getWinnerBracketRoundName,"winner_bracket",i),n){const n=(0,s.splitBy)(e[1],"round_id").map((t=>(0,s.sortBy)(t,"number")));this.renderBracket(t,n,c.getLoserBracketRoundName,"loser_bracket")}o&&(this.renderFinal(t,"grand_final",a),this.renderFinal(t,"consolation_final",u))}getFinalInfoSingleElimination(t){var e;return{hasFinal:void 0!==t[1],connectFinal:!1,finalMatches:(0,s.sortBy)(null!==(e=t[1])&&void 0!==e?e:[],"number")}}getFinalInfoDoubleElimination(t){var e;const n=void 0!==t[2],r=(0,s.sortBy)(null!==(e=t[2])&&void 0!==e?e:[],"number"),o=r.filter((t=>1===t.number)),i=r.filter((t=>2===t.number));return{hasFinal:n,connectFinal:o.length>0,grandFinalMatches:o,consolationFinalMatches:i}}renderBracket(t,e,n,r,o){const i=e[0][0].group_id,a=e.length,d=u.createBracketContainer(i,c.getBracketName(this.stage,r)),p=u.createRoundsContainer(),{matches:f,fromToornament:h}=(0,s.completeWithBlankMatches)(r,e[0],e[1]);this.alwaysConnectFirstRound=!h;for(let t=0;t<e.length;t++){const i=e[t][0].round_id,s=t+1,d=this.getRoundName({roundNumber:s,roundCount:a,fractionOfFinal:l.helpers.getFractionOfFinal(s,a),groupType:c.toI18nKey(r)},n),g=u.createRoundContainer(i,d),m=h&&1===s?f:e[t];for(const t of m)g.append(t&&this.createBracketMatch({...t,metadata:{...t.metadata,roundNumber:s,roundCount:a,matchLocation:r,connectFinal:o}})||this.skipBracketMatch());p.append(g)}d.append(p),t.append(d)}renderFinal(t,e,n){if(0===n.length)return;const r=t.querySelector(".bracket .rounds");if(!r)throw Error("Upper bracket not found.");const o=n[0].opponent1,i=null===(null==o?void 0:o.id)||"win"===(null==o?void 0:o.result)?1:2,a=n.slice(0,i),s=a.length,l=({roundNumber:t,roundCount:n})=>c.getFinalMatchLabel(e,t,n);for(let t=0;t<a.length;t++){const n=t+1,o=this.getRoundName({roundNumber:n,roundCount:s,groupType:c.toI18nKey("final_group"),finalType:c.toI18nKey(e)},l),i={...a[t],metadata:{...a[t].metadata,roundNumber:n,roundCount:s,matchLocation:"final_group"}},d=u.createRoundContainer(i.round_id,o);d.append(this.createFinalMatch(e,i)),r.append(d)}}createRanking(t){const e=u.createTable(),n=l.helpers.getRanking(t,this.config.rankingFormula);e.append(u.createRankingHeaders(n));for(const t of n)e.append(this.createRankingRow(t));return e}createRankingRow(t){const e=u.createRow(),n=0===t.played;for(const r in t){const o=r,i=t[o];if("id"===o){const t=this.participants.find((t=>t.id===i));if(void 0!==t){const n=u.createCell(t.name);this.setupMouseHover(t.id,n,!0),e.append(n);continue}}!n||"rank"!==o&&"points"!==o?e.append(u.createCell(i)):e.append(u.createCell("-"))}return e}createBracketMatch(t){const{roundNumber:e,roundCount:n,matchLocation:r,connectFinal:o}=t.metadata;if(void 0===e||void 0===n||void 0===r)throw Error(`The match's internal data is missing roundNumber, roundCount or matchLocation: ${JSON.stringify(t)}`);const i=u.getBracketConnection(this.alwaysConnectFirstRound,e,n,t,r,o),a=c.getMatchLabel(t.number,e,n,r),s=c.getOriginHint(e,n,this.skipFirstRound,r);return t.metadata.connection=i,t.metadata.label=a,t.metadata.originHint=s,this.createMatch(t,!0)}createFinalMatch(t,e){const{roundNumber:n,roundCount:r}=e.metadata;if(void 0===n||void 0===r)throw Error(`The match's internal data is missing roundNumber or roundCount: ${JSON.stringify(e)}`);const o=u.getFinalConnection(t,n,r),i=c.getFinalMatchLabel(t,n,r),a=c.getFinalOriginHint(e.metadata.stageType,t,n);return e.metadata.connection=o,e.metadata.label=i,e.metadata.originHint=a,this.createMatch(e,!0)}skipBracketMatch(){const t=u.createMatchContainer(),e=u.createOpponentsContainer(),n=this.createParticipant(null,!0),r=this.createParticipant(null,!0);return e.append(n,r),t.append(e),t.style.visibility="hidden",t}createMatch(t,e){const n=u.createMatchContainer(t),r=(0,s.isMatch)(t)?u.createOpponentsContainer((()=>this._onMatchClick(t))):u.createOpponentsContainer();if((0,s.isMatch)(t)&&t.status>=a.Status.Completed&&(t.metadata.originHint=void 0),(0,s.isMatch)(t)){const{originHint:n,matchLocation:o,roundNumber:i}=t.metadata,a=this.createParticipant(t.opponent1,e,"opponent1",n,o,i),s=this.createParticipant(t.opponent2,e,"opponent2",n,o,i);this.renderMatchLabel(r,t),r.append(a,s)}else{const n=this.createParticipant(t.opponent1,e,"opponent1"),o=this.createParticipant(t.opponent2,e,"opponent2");this.renderMatchLabel(r,t),r.append(n,o)}if(n.append(r),(0,s.isMatch)(t)){if(!t.metadata.connection)return n;u.setupConnection(r,n,t.metadata.connection)}return n}createParticipant(t,e,n,r,o,i){const a={participant:u.createParticipantContainer(t&&t.id),name:u.createNameContainer(),result:u.createResultContainer()};return null==t?u.setupBye(a.name):this.renderParticipant(a,t,n,r,o,i),a.participant.append(a.name,a.result),t&&null!==t.id&&this.setupMouseHover(t.id,a.participant,e),a.participant}renderParticipant(t,e,n,r,o,i){const a=this.participants.find((t=>t.id===e.id));a?(t.name.innerText=a.name,t.participant.setAttribute("title",a.name),this.renderParticipantImage(t.name,a.id),this.renderParticipantOrigin(t.name,e,n,o,i)):this.renderHint(t.name,e,r,o),t.result.innerText=`${void 0===e.score?"-":e.score}`,u.setupWin(t.participant,t.result,e),u.setupLoss(t.participant,t.result,e)}renderParticipantImage(t,e){const n=this.participantImages.find((t=>t.participantId===e));n&&u.addParticipantImage(t,n.imageUrl)}renderMatchLabel(t,e){const{label:n}=e.metadata;if((0,s.isMatchGame)(e))return void t.append(u.createMatchLabel(n,c.getMatchStatus(e.status)));const r=n=>{n.stopPropagation(),this._onMatchLabelClick(e),e.child_count>0&&this.config.showPopoverOnMatchLabelClick&&(this.clearPreviousPopoverSelections(),t.classList.add("popover-selected"),this.showPopover(e))};if(this.config.separatedChildCountLabel)return t.append(u.createMatchLabel(n,c.getMatchStatus(e.status),r)),void(e.child_count>0&&t.append(u.createChildCountLabel(c.t("common.best-of-x",{x:e.child_count}),r)));if(e.child_count>0){const o=c.t("common.best-of-x",{x:e.child_count}),i=n?`${n}, ${o}`:o;t.append(u.createMatchLabel(i,c.getMatchStatus(e.status),r))}}showPopover(t){this.popover.innerText="";const{roundNumber:e,roundCount:n,matchLocation:r}=t.metadata,o=c.getMatchLabel(t.number,e,n,r),i=u.createPopoverTitle(o);this.popover.append(i);for(const e of t.metadata.games){const t=c.t("match-label.match-game",{gameNumber:e.number}),n=this.createMatch({...e,metadata:{label:t}},!1);this.popover.append(n)}try{this.popover.togglePopover()}catch{}}renderHint(t,e,n,r){void 0!==n&&void 0!==e.position&&this.config.showSlotsOrigin&&(this.config.showLowerBracketSlotsOrigin||"loser_bracket"!==r)&&u.setupHint(t,n(e.position))}renderParticipantOrigin(t,e,n,r,o){if(void 0===e.position||void 0===r)return;if(!this.config.participantOriginPlacement||"none"===this.config.participantOriginPlacement)return;if(!this.config.showSlotsOrigin)return;if(!this.config.showLowerBracketSlotsOrigin&&"loser_bracket"===r)return;const i=(0,s.getOriginAbbreviation)(r,this.skipFirstRound,o,n);if(!i)return;const a=`${i}${e.position}`;u.addParticipantOrigin(t,a,this.config.participantOriginPlacement)}setupMouseHover(t,e,n){if(!this.config.highlightParticipantOnHover)return;const r=t=>{e.addEventListener("mouseenter",(()=>{t.forEach((t=>t.classList.add("hover")))})),e.addEventListener("mouseleave",(()=>{t.forEach((t=>t.classList.remove("hover")))}))};if(!n)return void r([e]);const o=this.participantRefs[t];if(!o)throw Error(`The participant (id: ${t}) does not exist in the participants table.`);o.push(e),r(o)}clearPreviousPopoverSelections(){var t;null===(t=document.querySelector(".opponents.popover-selected"))||void 0===t||t.classList.remove("popover-selected")}}},1834:function(t,e){"use strict";Object.defineProperty(e,"__esModule",{value:!0})},945:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.BaseGetter=void 0;const r=n(4487);e.BaseGetter=class{constructor(t){this.storage=t}async getOrderedRounds(t){if(!(null==t?void 0:t.settings.size))throw Error("The stage has no size.");return"single_elimination"===t.type?this.getOrderedRoundsSingleElimination(t.id):this.getOrderedRoundsDoubleElimination(t.id)}async getOrderedRoundsSingleElimination(t){return[await this.getUpperBracketFirstRound(t)]}async getOrderedRoundsDoubleElimination(t){const e=await this.storage.select("round",{stage_id:t});if(!e)throw Error("Error getting rounds.");const n=await this.getLoserBracket(t);if(!n)throw Error("Loser bracket not found.");const o=e[0],i=e.filter((t=>t.group_id===n.id));return[o,...i.filter((t=>r.isOrderingSupportedLoserBracket(t.number,i.length)))]}async getRoundPositionalInfo(t){const e=await this.storage.select("round",t);if(!e)throw Error("Round not found.");const n=await this.storage.select("round",{group_id:e.group_id});if(!n)throw Error("Error getting rounds.");return{roundNumber:e.number,roundCount:n.length}}async getPreviousMatches(t,e,n,r){return"loser_bracket"===e?this.getPreviousMatchesLB(t,n,r):"final_group"===e?this.getPreviousMatchesFinal(t,n,r):1===r?[]:this.getMatchesBeforeMajorRound(t,r)}async getPreviousMatchesFinal(t,e,n){return"single_elimination"===e.type?this.getPreviousMatchesFinalSingleElimination(t,e):this.getPreviousMatchesFinalDoubleElimination(t,n)}async getPreviousMatchesFinalSingleElimination(t,e){const n=await this.getUpperBracket(t.stage_id),o=r.getUpperBracketRoundCount(e.settings.size),i=await this.storage.selectFirst("round",{group_id:n.id,number:o-1});if(!i)throw Error("Semi finals round not found.");const a=await this.storage.select("match",{round_id:i.id});if(!a)throw Error("Error getting semi final matches.");return a}async getPreviousMatchesFinalDoubleElimination(t,e){if(e>1)return[await this.findMatch(t.group_id,e-1,1)];const n=await this.getUpperBracket(t.stage_id),r=await this.getLastRound(n.id),o=await this.storage.selectFirst("match",{round_id:r.id,number:1});if(!o)throw Error("Match not found.");const i=await this.getLoserBracket(t.stage_id);if(!i)throw Error("Loser bracket not found.");const a=await this.getLastRound(i.id),s=await this.storage.selectFirst("match",{round_id:a.id,number:1});if(!s)throw Error("Match not found.");return[o,s]}async getPreviousMatchesLB(t,e,n){if(e.settings.skipFirstRound&&1===n)return[];if(r.hasBye(t))return[];const o=await this.getUpperBracket(t.stage_id),i=Math.ceil((n+1)/2),a=e.settings.skipFirstRound?i-1:i;return 1===n?this.getMatchesBeforeFirstRoundLB(t,o.id,a):r.isMajorRound(n)?this.getMatchesBeforeMajorRound(t,n):this.getMatchesBeforeMinorRoundLB(t,o.id,n,a)}async getMatchesBeforeMajorRound(t,e){return[await this.findMatch(t.group_id,e-1,2*t.number-1),await this.findMatch(t.group_id,e-1,2*t.number)]}async getMatchesBeforeFirstRoundLB(t,e,n){return[await this.findMatch(e,n,r.getOriginPosition(t,"opponent1")),await this.findMatch(e,n,r.getOriginPosition(t,"opponent2"))]}async getMatchesBeforeMinorRoundLB(t,e,n,o){const i=r.getOriginPosition(t,"opponent1");return[await this.findMatch(e,o,i),await this.findMatch(t.group_id,n-1,t.number)]}async getNextMatches(t,e,n,r,o){switch(e){case"single_bracket":return this.getNextMatchesUpperBracket(t,n,r,o);case"winner_bracket":return this.getNextMatchesWB(t,n,r,o);case"loser_bracket":return this.getNextMatchesLB(t,n,r,o);case"final_group":return this.getNextMatchesFinal(t,n,r,o);default:throw Error("Unknown bracket kind.")}}async getNextMatchesWB(t,e,n,o){const i=await this.getLoserBracket(t.stage_id);if(null===i)return[];const a=e.settings.skipFirstRound?n+1:n,s=a>1?2*(a-1):1,u=e.settings.size,c=r.getLoserOrdering(e.settings.seedOrdering,s),l=r.findLoserMatchNumber(u,s,t.number,c);return[...await this.getNextMatchesUpperBracket(t,e,n,o),await this.findMatch(i.id,s,l)]}async getNextMatchesUpperBracket(t,e,n,r){return"single_elimination"===e.type?this.getNextMatchesUpperBracketSingleElimination(t,e.type,n,r):this.getNextMatchesUpperBracketDoubleElimination(t,e.type,n,r)}async getNextMatchesUpperBracketSingleElimination(t,e,n,r){if(n===r-1){const r=await this.getFinalGroupId(t.stage_id,e),o=await this.getFinalGroupFirstMatch(r);return[await this.getDiagonalMatch(t.group_id,n,t.number),...o?[o]:[]]}return n===r?[]:[await this.getDiagonalMatch(t.group_id,n,t.number)]}async getNextMatchesUpperBracketDoubleElimination(t,e,n,r){if(n===r){const n=await this.getFinalGroupId(t.stage_id,e);return[await this.getFinalGroupFirstMatch(n)]}return[await this.getDiagonalMatch(t.group_id,n,t.number)]}async getNextMatchesLB(t,e,n,o){if(n===o-1){const r=await this.getFinalGroupId(t.stage_id,e.type),o=await this.getConsolationFinalMatchDoubleElimination(r);return[...await this.getMatchAfterMajorRoundLB(t,n),...o?[o]:[]]}if(n===o){const n=await this.getFinalGroupId(t.stage_id,e.type),r=await this.getFinalGroupFirstMatch(n),o=await this.getConsolationFinalMatchDoubleElimination(n);return[r,...o?[o]:[]]}return r.isMajorRound(n)?this.getMatchAfterMajorRoundLB(t,n):this.getMatchAfterMinorRoundLB(t,n)}async getFinalGroupFirstMatch(t){return null===t?null:this.findMatch(t,1,1)}async getConsolationFinalMatchDoubleElimination(t){return null===t?null:this.storage.selectFirst("match",{group_id:t,number:2})}async getNextMatchesFinal(t,e,n,r){return n===r||e.settings.consolationFinal&&1===t.number&&n===r-1?[]:[await this.findMatch(t.group_id,n+1,1)]}async getMatchAfterMajorRoundLB(t,e){return[await this.getParallelMatch(t.group_id,e,t.number)]}async getMatchAfterMinorRoundLB(t,e){return[await this.getDiagonalMatch(t.group_id,e,t.number)]}static getSeedingOrdering(t,e){return"round_robin"===t?e.getRoundRobinOrdering():e.getStandardBracketFirstRoundOrdering()}async getSeedingMatches(t,e){if("round_robin"===e)return this.storage.select("match",{stage_id:t});try{const e=await this.getUpperBracketFirstRound(t);return this.storage.select("match",{round_id:e.id})}catch{return[]}}async getUpperBracketFirstRound(t){const e=await this.storage.selectFirst("round",{stage_id:t,number:1},!1);if(!e)throw Error("Round not found.");return e}async getLastRound(t){const e=await this.storage.selectLast("round",{group_id:t},!1);if(!e)throw Error("Error getting rounds.");return e}async getFinalGroupId(t,e){const n="single_elimination"===e?2:3,r=await this.storage.selectFirst("group",{stage_id:t,number:n});return r?r.id:null}async getUpperBracket(t){const e=await this.storage.selectFirst("group",{stage_id:t,number:1});if(!e)throw Error("Winner bracket not found.");return e}async getLoserBracket(t){return this.storage.selectFirst("group",{stage_id:t,number:2})}async getDiagonalMatch(t,e,n){return this.findMatch(t,e+1,r.getDiagonalMatchNumber(n))}async getParallelMatch(t,e,n){return this.findMatch(t,e+1,n)}async findMatch(t,e,n){const r=await this.storage.selectFirst("round",{group_id:t,number:e});if(!r)throw Error("Round not found.");const o=await this.storage.selectFirst("match",{round_id:r.id,number:n});if(!o)throw Error("Match not found.");return o}async findMatchGame(t){if(void 0!==t.id){const e=await this.storage.select("match_game",t.id);if(!e)throw Error("Match game not found.");return e}if(void 0!==t.parent_id&&t.number){const e=await this.storage.selectFirst("match_game",{parent_id:t.parent_id,number:t.number});if(!e)throw Error("Match game not found.");return e}throw Error("No match game id nor parent id and number given.")}}},4267:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.StageCreator=e.create=void 0;const r=n(2644),o=n(4487);e.create=async function(t){return new i(this.storage,t).run()};class i{constructor(t,e){if(this.storage=t,this.stage=e,this.stage.settings=this.stage.settings||{},this.seedOrdering=[...this.stage.settings.seedOrdering||[]],this.updateMode=!1,this.enableByesInUpdate=!1,!this.stage.name)throw Error("You must provide a name for the stage.");if(void 0===this.stage.tournamentId)throw Error("You must provide a tournament id for the stage.");"round_robin"===e.type&&(this.stage.settings.roundRobinMode=this.stage.settings.roundRobinMode||"simple"),"single_elimination"===e.type&&(this.stage.settings.consolationFinal=this.stage.settings.consolationFinal||!1),"double_elimination"===e.type&&(this.stage.settings.grandFinal=this.stage.settings.grandFinal||"none"),this.stage.settings.matchesChildCount=this.stage.settings.matchesChildCount||0}async run(){let t;switch(this.stage.type){case"round_robin":t=await this.roundRobin();break;case"single_elimination":t=await this.singleElimination();break;case"double_elimination":t=await this.doubleElimination();break;default:throw Error("Unknown stage type.")}if(-1===t.id)throw Error("Something went wrong when creating the stage.");return await this.ensureSeedOrdering(t.id),t}setExisting(t,e){this.updateMode=!0,this.currentStageId=t,this.enableByesInUpdate=e}async roundRobin(){const t=await this.getRoundRobinGroups(),e=await this.createStage();for(let n=0;n<t.length;n++)await this.createRoundRobinGroup(e.id,n+1,t[n]);return e}async singleElimination(){var t,e;if(Array.isArray(null===(t=this.stage.settings)||void 0===t?void 0:t.seedOrdering)&&1!==(null===(e=this.stage.settings)||void 0===e?void 0:e.seedOrdering.length))throw Error("You must specify one seed ordering method.");const n=await this.getSlots(),o=await this.createStage(),i=this.getStandardBracketFirstRoundOrdering(),a=r.ordering[i](n),{losers:s}=await this.createStandardBracket(o.id,1,a);return await this.createConsolationFinal(o.id,s),o}async doubleElimination(){var t;if(this.stage.settings&&Array.isArray(this.stage.settings.seedOrdering)&&this.stage.settings.seedOrdering.length<1)throw Error("You must specify at least one seed ordering method.");const e=await this.getSlots(),n=await this.createStage(),o=this.getStandardBracketFirstRoundOrdering(),i=r.ordering[o](e);return(null===(t=this.stage.settings)||void 0===t?void 0:t.skipFirstRound)?await this.createDoubleEliminationSkipFirstRound(n.id,i):await this.createDoubleElimination(n.id,i),n}async createDoubleEliminationSkipFirstRound(t,e){var n;const{even:r,odd:i}=o.splitByParity(e),{losers:a,winner:s}=await this.createStandardBracket(t,1,r);if(o.isDoubleEliminationNecessary(null===(n=this.stage.settings)||void 0===n?void 0:n.size)){const e=await this.createLowerBracket(t,2,[i,...a]);await this.createGrandFinal(t,s,e)}}async createDoubleElimination(t,e){var n;const{losers:r,winner:i}=await this.createStandardBracket(t,1,e);if(o.isDoubleEliminationNecessary(null===(n=this.stage.settings)||void 0===n?void 0:n.size)){const e=await this.createLowerBracket(t,2,r),n=await this.createGrandFinal(t,i,e);await this.createConsolationFinal(t,r,{existingGroupId:n,matchNumberStart:2})}}async createRoundRobinGroup(t,e,n){var r;const i=await this.insertGroup({stage_id:t,number:e});if(-1===i)throw Error("Could not insert the group.");const a=o.makeRoundRobinMatches(n,null===(r=this.stage.settings)||void 0===r?void 0:r.roundRobinMode);for(let e=0;e<a.length;e++)await this.createRound(t,i,e+1,a[0].length,a[e])}async createStandardBracket(t,e,n){const r=o.getUpperBracketRoundCount(n.length),i=await this.insertGroup({stage_id:t,number:e});if(-1===i)throw Error("Could not insert the group.");let a=o.makePairs(n),s=1;const u=[];for(let e=r-1;e>=0;e--){const n=Math.pow(2,e);a=this.getCurrentDuels(a,n),u.push(a.map(o.byeLoser)),await this.createRound(t,i,s++,n,a)}return{losers:u,winner:o.byeWinner(a[0])}}async createLowerBracket(t,e,n){var i;const a=null===(i=this.stage.settings)||void 0===i?void 0:i.size,s=o.getRoundPairCount(a);let u=0;const c=this.getMajorOrdering(a),l=r.ordering[c](n[u++]),d=await this.insertGroup({stage_id:t,number:e});if(-1===d)throw Error("Could not insert the group.");let p=o.makePairs(l),f=1;for(let e=0;e<s;e++){const r=Math.pow(2,s-e-1);p=this.getCurrentDuels(p,r,!0),await this.createRound(t,d,f++,r,p);const o=this.getMinorOrdering(a,e,s);p=this.getCurrentDuels(p,r,!1,n[u++],o),await this.createRound(t,d,f++,r,p)}return o.byeWinnerToGrandFinal(p[0])}async createUniqueMatchBracket(t,e,n,r={}){let o=r.existingGroupId,i=1;if(void 0!==o){const t=await this.storage.select("round",{group_id:o});if(!t)throw Error("Error getting rounds.");i=t.length+1}else if(o=await this.insertGroup({stage_id:t,number:e}),-1===o)throw Error("Could not insert the group.");for(let e=0;e<n.length;e++)await this.createRound(t,o,i+e,1,[n[e]],r.matchNumberStart);return o}async createRound(t,e,n,r,o,i=1){const a=this.getMatchesChildCount(),s=await this.insertRound({number:n,stage_id:t,group_id:e});if(-1===s)throw Error("Could not insert the round.");for(let n=0;n<r;n++)await this.createMatch(t,e,s,i+n,o[n],a)}async createMatch(t,e,n,r,i,a){const s=o.toResultWithPosition(i[0]),u=o.toResultWithPosition(i[1]);if("round_robin"===this.stage.type&&null===s&&null===u)return;let c=null,l=o.getMatchStatus(i);if(this.updateMode){c=await this.storage.selectFirst("match",{round_id:n,number:r});const t=null==c?void 0:c.child_count;if(a=void 0===t?a:t,c){const t=o.getMatchStatus(c);t>l&&(l=t)}}const d=await this.insertMatch({number:r,stage_id:t,group_id:e,round_id:n,child_count:a,status:l,...o.getInferredResult(s,u)},c);if(-1===d)throw Error("Could not insert the match.");for(let e=0;e<a;e++)if(-1===await this.insertMatchGame({number:e+1,stage_id:t,parent_id:d,status:l,...o.getInferredResult(o.toResult(i[0]),o.toResult(i[1]))}))throw Error("Could not insert the match game.")}getCurrentDuels(t,e,n,r,i){return void 0!==n&&!n||t.length!==e?void 0===n||n?o.transitionToMajor(t):o.transitionToMinor(t,r,i):t}async getSlots(t){var e;let n=this.stage.seedingIds||this.stage.seeding;const r=(null===(e=this.stage.settings)||void 0===e?void 0:e.size)||(null==n?void 0:n.length)||0;if(o.ensureValidSize(this.stage.type,r),r&&!n)return Array.from({length:r},((t,e)=>({id:null,position:e+1})));if(!n)throw Error("Either size or seeding must be given.");return this.stage.settings={...this.stage.settings,size:r},o.ensureNoDuplicates(n),n=o.fixSeeding(n,r),"round_robin"!==this.stage.type&&this.stage.settings.balanceByes&&(n=o.balanceByes(n,this.stage.settings.size)),this.stage.seeding=n,void 0!==this.stage.seedingIds||o.isSeedingWithIds(n)?this.getSlotsUsingIds(n,t):this.getSlotsUsingNames(n,t)}async getSlotsUsingNames(t,e){const n=o.extractParticipantsFromSeeding(this.stage.tournamentId,t);if(!await this.registerParticipants(n))throw Error("Error registering the participants.");const r=await this.storage.select("participant",{tournament_id:this.stage.tournamentId});if(!r)throw Error("Error getting registered participant.");return o.mapParticipantsNamesToDatabase(t,r,e)}async getSlotsUsingIds(t,e){const n=await this.storage.select("participant",{tournament_id:this.stage.tournamentId});if(!n)throw Error("No available participants.");return o.mapParticipantsIdsToDatabase(t,n,e)}async getStageNumber(){const t=await this.storage.select("stage",{tournament_id:this.stage.tournamentId}),e=null==t?void 0:t.map((t=>{var e;return null!==(e=t.number)&&void 0!==e?e:0}));if(void 0!==this.stage.number){if(null==e?void 0:e.includes(this.stage.number))throw Error("The given stage number already exists.");return this.stage.number}return(null==e?void 0:e.length)?Math.max(...e)+1:1}getMatchesChildCount(){var t;return(null===(t=this.stage.settings)||void 0===t?void 0:t.matchesChildCount)?this.stage.settings.matchesChildCount:0}getOrdering(t,e,n){var r;if(!(null===(r=this.stage.settings)||void 0===r?void 0:r.seedOrdering))return this.seedOrdering.push(n),n;const o=this.stage.settings.seedOrdering[t];if(!o)return this.seedOrdering.push(n),n;if("elimination"===e&&o.match(/^groups\./))throw Error("You must specify a seed ordering method without a 'groups' prefix");if("groups"===e&&"natural"!==o&&!o.match(/^groups\./))throw Error("You must specify a seed ordering method with a 'groups' prefix");return o}async getRoundRobinGroups(){var t,e,n,i,a;if(void 0===(null===(t=this.stage.settings)||void 0===t?void 0:t.groupCount)||!Number.isInteger(this.stage.settings.groupCount))throw Error("You must specify a group count for round-robin stages.");if(this.stage.settings.groupCount<=0)throw Error("You must provide a strictly positive group count.");if(null===(e=this.stage.settings)||void 0===e?void 0:e.manualOrdering){if((null===(n=this.stage.settings)||void 0===n?void 0:n.manualOrdering.length)!==(null===(i=this.stage.settings)||void 0===i?void 0:i.groupCount))throw Error("Group count in the manual ordering does not correspond to the given group count.");const t=null===(a=this.stage.settings)||void 0===a?void 0:a.manualOrdering.flat(),e=await this.getSlots(t);return o.makeGroups(e,this.stage.settings.groupCount)}if(Array.isArray(this.stage.settings.seedOrdering)&&1!==this.stage.settings.seedOrdering.length)throw Error("You must specify one seed ordering method.");const s=this.getRoundRobinOrdering(),u=await this.getSlots(),c=r.ordering[s](u,this.stage.settings.groupCount);return o.makeGroups(c,this.stage.settings.groupCount)}getRoundRobinOrdering(){return this.getOrdering(0,"groups","groups.effort_balanced")}getStandardBracketFirstRoundOrdering(){return this.getOrdering(0,"elimination","inner_outer")}getMajorOrdering(t){var e;return this.getOrdering(1,"elimination",(null===(e=r.defaultMinorOrdering[t])||void 0===e?void 0:e[0])||"natural")}getMinorOrdering(t,e,n){var o;if(e!==n-1)return this.getOrdering(2+e,"elimination",(null===(o=r.defaultMinorOrdering[t])||void 0===o?void 0:o[1+e])||"natural")}async insertStage(t){let e=null;if(this.updateMode){if(e=await this.storage.select("stage",this.currentStageId),!e)throw Error("Stage not found.");const n={...e,...t,settings:{...e.settings,...t.settings}};if(!await this.storage.update("stage",this.currentStageId,n))throw Error("Could not update the stage.")}return e?e.id:this.storage.insert("stage",t)}async insertGroup(t){let e=null;return this.updateMode&&(e=await this.storage.selectFirst("group",{stage_id:t.stage_id,number:t.number})),e?e.id:this.storage.insert("group",t)}async insertRound(t){let e=null;return this.updateMode&&(e=await this.storage.selectFirst("round",{group_id:t.group_id,number:t.number})),e?e.id:this.storage.insert("round",t)}async insertMatch(t,e){if(!e)return this.storage.insert("match",t);const n=o.getUpdatedMatchResults(t,e,this.enableByesInUpdate);if(!await this.storage.update("match",e.id,n))throw Error("Could not update the match.");return e.id}async insertMatchGame(t){let e=null;if(this.updateMode&&(e=await this.storage.selectFirst("match_game",{parent_id:t.parent_id,number:t.number})),!e)return this.storage.insert("match_game",t);const n=o.getUpdatedMatchResults(t,e,this.enableByesInUpdate);if(!await this.storage.update("match_game",e.id,n))throw Error("Could not update the match game.");return e.id}async registerParticipants(t){const e=await this.storage.select("participant",{tournament_id:this.stage.tournamentId});if(!e||0===e.length)return this.storage.insert("participant",t);for(const n of t)if(!e.some((t=>t.name===n.name))&&-1===await this.storage.insert("participant",n))return!1;return!0}async createStage(){const t=await this.getStageNumber(),e={tournament_id:this.stage.tournamentId,name:this.stage.name,type:this.stage.type,number:t,settings:this.stage.settings||{}},n=await this.insertStage(e);if(-1===n)throw Error("Could not insert the stage.");return{...e,id:n}}async createConsolationFinal(t,e,n={}){var r;if(!(null===(r=this.stage.settings)||void 0===r?void 0:r.consolationFinal))return;const o=e[e.length-2];await this.createUniqueMatchBracket(t,2,[o],n)}async createGrandFinal(t,e,n){var r;const o=null===(r=this.stage.settings)||void 0===r?void 0:r.grandFinal;if("none"===o)return;const i=[[e,n]];return"double"===o&&i.push([{id:null},{id:null}]),await this.createUniqueMatchBracket(t,3,i)}async ensureSeedOrdering(t){var e,n;if((null===(n=null===(e=this.stage.settings)||void 0===e?void 0:e.seedOrdering)||void 0===n?void 0:n.length)===this.seedOrdering.length)return;const r=await this.storage.select("stage",t);if(!r)throw Error("Stage not found.");const o={...r,settings:{...r.settings,seedOrdering:this.seedOrdering}};if(!await this.storage.update("stage",t,o))throw Error("Could not update the stage.")}}e.StageCreator=i},3517:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.BaseUpdater=void 0;const r=n(7021),o=n(2644),i=n(4267),a=n(945),s=n(3576),u=n(4487);class c extends a.BaseGetter{async updateSeeding(t,{seeding:e,seedingIds:n},r){var s,u;const l=await this.storage.select("stage",t);if(!l)throw Error("Stage not found.");const d=r?l.settings.size:null!==(u=null===(s=n||e)||void 0===s?void 0:s.length)&&void 0!==u?u:0,p=new i.StageCreator(this.storage,{name:l.name,tournamentId:l.tournament_id,type:l.type,settings:{...l.settings,...0===d?{}:{size:d}},...n?{seedingIds:n}:{seeding:null!=e?e:void 0}});p.setExisting(t,!1);const f=a.BaseGetter.getSeedingOrdering(l.type,p),h=await p.getSlots(),g=await this.getSeedingMatches(l.id,l.type);if(!g)throw Error("Error getting matches associated to the seeding.");const m=o.ordering[f](h);c.assertCanUpdateSeeding(g,m),await p.run()}async confirmCurrentSeeding(t){const e=await this.storage.select("stage",t);if(!e)throw Error("Stage not found.");const n=new s.Get(this.storage),r=await n.seeding(t),o=u.convertSlotsToSeeding(r.map(u.convertTBDtoBYE)),a=new i.StageCreator(this.storage,{name:e.name,tournamentId:e.tournament_id,type:e.type,settings:e.settings,seeding:o});a.setExisting(t,!0),await a.run()}async updateParentMatch(t,e){const n=await this.storage.select("match",t);if(!n)throw Error("Parent not found.");const r=await this.storage.select("match_game",{parent_id:t});if(!r)throw Error("No match games.");const o=u.getChildGamesResults(r),i=u.getParentMatchResults(n,o);u.setParentMatchCompleted(i,n.child_count,e),await this.updateMatch(n,i,!0)}static assertCanUpdateSeeding(t,e){var n,o;let i=0;for(const a of t){if(a.status===r.Status.Archived)throw Error("A match of round 1 is archived, which means round 2 was started.");const t=e[i++],s=e[i++];if(u.isMatchParticipantLocked(a)&&((null===(n=a.opponent1)||void 0===n?void 0:n.id)!==(null==t?void 0:t.id)||(null===(o=a.opponent2)||void 0===o?void 0:o.id)!==(null==s?void 0:s.id)))throw Error("A match is locked.")}}async updateRelatedMatches(t,e,n){if(void 0===t.round_id)return;const{roundNumber:r,roundCount:o}=await this.getRoundPositionalInfo(t.round_id),i=await this.storage.select("stage",t.stage_id);if(!i)throw Error("Stage not found.");const a=await this.storage.select("group",t.group_id);if(!a)throw Error("Group not found.");const s=u.getMatchLocation(i.type,a.number);e&&await this.updatePrevious(t,s,i,r),n&&await this.updateNext(t,s,i,r,o)}async updateMatch(t,e,n){if(!n&&u.isMatchUpdateLocked(t))throw Error("The match is locked.");const r=await this.storage.select("stage",t.stage_id);if(!r)throw Error("Stage not found.");const o=u.isRoundRobin(r),{statusChanged:i,resultChanged:a}=u.setMatchResults(t,e,o);await this.applyMatchUpdate(t),(i||a)&&(u.isRoundRobin(r)||await this.updateRelatedMatches(t,i,a))}async updateMatchGame(t,e){if(u.isMatchUpdateLocked(t))throw Error("The match game is locked.");const n=await this.storage.select("stage",t.stage_id);if(!n)throw Error("Stage not found.");const r=u.isRoundRobin(n);if(u.setMatchResults(t,e,r),!await this.storage.update("match_game",t.id,t))throw Error("Could not update the match game.");await this.updateParentMatch(t.parent_id,r)}async applyMatchUpdate(t){if(!await this.storage.update("match",t.id,t))throw Error("Could not update the match.");if(0===t.child_count)return;const e={opponent1:u.toResult(t.opponent1),opponent2:u.toResult(t.opponent2)};if((t.status<=r.Status.Ready||t.status===r.Status.Archived)&&(e.status=t.status),!await this.storage.update("match_game",{parent_id:t.id},e))throw Error("Could not update the match game.")}async updatePrevious(t,e,n,o){const i=await this.getPreviousMatches(t,e,n,o);0!==i.length&&(t.status>=r.Status.Running?await this.archiveMatches(i):await this.resetMatchesStatus(i))}async archiveMatches(t){for(const e of t)e.status!==r.Status.Archived&&(e.status=r.Status.Archived,await this.applyMatchUpdate(e))}async resetMatchesStatus(t){for(const e of t)e.status=u.getMatchStatus(e),await this.applyMatchUpdate(e)}async updateNext(t,e,n,o,i){const a=await this.getNextMatches(t,e,n,o,i);if(0===a.length)return void(t.status===r.Status.Completed&&await this.archiveMatches([t]));const s=u.getMatchResult(t),c=n.settings.skipFirstRound&&"winner_bracket"===e?o+1:o;s?await this.applyToNextMatches(u.setNextOpponent,t,e,c,i,a,s):await this.applyToNextMatches(u.resetNextOpponent,t,e,c,i,a)}async applyToNextMatches(t,e,n,r,o,i,a){if("final_group"===n){if(!i[0])throw Error("First next match is null.");return t(i[0],"opponent1",e,"opponent1"),t(i[0],"opponent2",e,"opponent2"),void await this.applyMatchUpdate(i[0])}const s=u.getNextSide(e.number,r,o,n);if(i[0]&&(t(i[0],s,e,a),await this.propagateByeWinners(i[0])),2===i.length){if(!i[1])throw Error("Second next match is null.");if("single_bracket"===n)t(i[1],s,e,a&&u.getOtherSide(a)),await this.applyMatchUpdate(i[1]);else if("winner_bracket"===n){const n=u.getNextSideLoserBracket(e.number,i[1],r);t(i[1],n,e,a&&u.getOtherSide(a)),await this.propagateByeWinners(i[1])}else if("loser_bracket"===n){const n=u.getNextSideConsolationFinalDoubleElimination(r);t(i[1],n,e,a&&u.getOtherSide(a)),await this.propagateByeWinners(i[1])}}}async propagateByeWinners(t){u.setMatchResults(t,t,!1),await this.applyMatchUpdate(t),u.hasBye(t)&&await this.updateRelatedMatches(t,!0,!0)}}e.BaseUpdater=c},9765:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Create=void 0;const r=n(4267);e.Create=class{constructor(t){this.storage=t}async stage(t){return new r.StageCreator(this.storage,t).run()}}},4378:function(t,e){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Delete=void 0,e.Delete=class{constructor(t){this.storage=t}async stage(t){if(!await this.storage.delete("match_game",{stage_id:t}))throw Error("Could not delete match games.");if(!await this.storage.delete("match",{stage_id:t}))throw Error("Could not delete matches.");if(!await this.storage.delete("round",{stage_id:t}))throw Error("Could not delete rounds.");if(!await this.storage.delete("group",{stage_id:t}))throw Error("Could not delete groups.");if(!await this.storage.delete("stage",{id:t}))throw Error("Could not delete the stage.")}async tournament(t){const e=await this.storage.select("stage",{tournament_id:t});if(!e)throw Error("Error getting the stages.");for(const t of e)await this.stage(t.id)}}},4063:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Find=void 0;const r=n(945),o=n(4487);class i extends r.BaseGetter{async upperBracket(t){const e=await this.storage.select("stage",t);if(!e)throw Error("Stage not found.");switch(e.type){case"round_robin":throw Error("Round-robin stages do not have an upper bracket.");case"single_elimination":case"double_elimination":return this.getUpperBracket(t);default:throw Error("Unknown stage type.")}}async loserBracket(t){const e=await this.storage.select("stage",t);if(!e)throw Error("Stage not found.");switch(e.type){case"round_robin":throw Error("Round-robin stages do not have a loser bracket.");case"single_elimination":throw Error("Single elimination stages do not have a loser bracket.");case"double_elimination":const e=await this.getLoserBracket(t);if(!e)throw Error("Loser bracket not found.");return e;default:throw Error("Unknown stage type.")}}async previousMatches(t,e){const n=await this.storage.select("match",t);if(!n)throw Error("Match not found.");const r=await this.storage.select("stage",n.stage_id);if(!r)throw Error("Stage not found.");const i=await this.storage.select("group",n.group_id);if(!i)throw Error("Group not found.");const a=await this.storage.select("round",n.round_id);if(!a)throw Error("Round not found.");const s=o.getMatchLocation(r.type,i.number),u=await this.getPreviousMatches(n,s,r,a.number);return void 0!==e?u.filter((t=>o.isParticipantInMatch(t,e))):u}async nextMatches(t,e){const n=await this.storage.select("match",t);if(!n)throw Error("Match not found.");const r=await this.storage.select("stage",n.stage_id);if(!r)throw Error("Stage not found.");const i=await this.storage.select("group",n.group_id);if(!i)throw Error("Group not found.");const{roundNumber:a,roundCount:s}=await this.getRoundPositionalInfo(n.round_id),u=o.getMatchLocation(r.type,i.number),c=o.getNonNull(await this.getNextMatches(n,u,r,a,s));if(void 0!==e){if(!o.isParticipantInMatch(n,e))throw Error("The participant does not belong to this match.");if(!o.isMatchStale(n))throw Error("The match is not stale yet, so it is not possible to conclude the next matches for this participant.");const t=o.getLoser(n);if("single_elimination"===r.type&&(null==t?void 0:t.id)===e)return[];if("double_elimination"===r.type){const{winnerBracketMatch:r,loserBracketMatch:a,finalGroupMatch:s}=await this.getMatchesByGroupDoubleElimination(c,new Map([[i.id,i]])),l=o.getWinner(n);if("loser_bracket"===u){if(e===(null==t?void 0:t.id))return[];if(e===(null==l?void 0:l.id))return a?[a]:[]}else if("winner_bracket"===u){if(!a)throw Error("All matches of winner bracket should lead to loser bracket.");if(e===(null==t?void 0:t.id))return[a];if(e===(null==l?void 0:l.id))return r?[r]:[]}else if("final_group"===u){if(!s)throw Error("All matches of a final group should also lead to the final group.");return[s]}}}return c}async match(t,e,n){return this.findMatch(t,e,n)}async matchGame(t){return this.findMatchGame(t)}async getMatchesByGroupDoubleElimination(t,e){var n,r,i;const a=async t=>{const n=e.get(t);if(n)return n;const r=await this.storage.select("group",t);if(!r)throw Error("Group not found.");return e.set(t,r),r};let s={};for(const e of t){const t=await a(e.group_id);s={winnerBracketMatch:null!==(n=s.winnerBracketMatch)&&void 0!==n?n:o.isWinnerBracket("double_elimination",t.number)?e:void 0,loserBracketMatch:null!==(r=s.loserBracketMatch)&&void 0!==r?r:o.isLoserBracket("double_elimination",t.number)?e:void 0,finalGroupMatch:null!==(i=s.finalGroupMatch)&&void 0!==i?i:o.isFinalGroup("double_elimination",t.number)?e:void 0}}return s}}e.Find=i},3576:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Get=void 0;const r=n(7021),o=n(945),i=n(4487);class a extends o.BaseGetter{async stageData(t){const e=await this.getStageSpecificData(t),n=await this.storage.select("participant",{tournament_id:e.stage.tournament_id});if(!n)throw Error("Error getting participants.");return{stage:[e.stage],group:e.groups,round:e.rounds,match:e.matches,match_game:e.matchGames,participant:n}}async tournamentData(t){const e=await this.storage.select("stage",{tournament_id:t});if(!e)throw Error("Error getting stages.");const n=await Promise.all(e.map((t=>this.getStageSpecificData(t.id)))),r=await this.storage.select("participant",{tournament_id:t});if(!r)throw Error("Error getting participants.");return{stage:e,group:n.reduce(((t,e)=>[...t,...e.groups]),[]),round:n.reduce(((t,e)=>[...t,...e.rounds]),[]),match:n.reduce(((t,e)=>[...t,...e.matches]),[]),match_game:n.reduce(((t,e)=>[...t,...e.matchGames]),[]),participant:r}}async matchGames(t){const e=t.filter((t=>t.child_count>0)),n=await Promise.all(e.map((t=>this.storage.select("match_game",{parent_id:t.id}))));if(n.some((t=>null===t)))throw Error("Error getting match games.");return i.getNonNull(n).flat()}async currentStage(t){const e=await this.storage.select("stage",{tournament_id:t});if(!e)throw Error("Error getting stages.");for(const t of e){const e=await this.storage.select("match",{stage_id:t.id});if(!e)throw Error("Error getting matches.");if(!e.every((t=>t.status>=r.Status.Completed)))return t}return null}async currentRound(t){const e=await this.storage.select("match",{stage_id:t});if(!e)throw Error("Error getting matches.");const n=i.splitBy(e,"round_id");for(const t of n){if(t.every((t=>t.status>=r.Status.Completed)))continue;const e=await this.storage.select("round",t[0].round_id);if(!e)throw Error("Round not found.");return e}return null}async currentMatches(t){const e=await this.storage.select("stage",t);if(!e)throw Error("Stage not found.");if("single_elimination"!==e.type)throw Error("Not implemented for round robin and double elimination. Ask if needed.");const n=await this.storage.select("match",{stage_id:t});if(!n)throw Error("Error getting matches.");const r=i.splitBy(n,"round_id"),o=i.getUpperBracketRoundCount(e.settings.size);let a=-1;const s=[];for(const t of r){if(a++,e.settings.consolationFinal&&a===o-1){const[e]=t,[n]=r[a+1],o=[e,n];return o.every((t=>!i.isMatchOngoing(t)))?s:o.filter((t=>i.isMatchOngoing(t)))}t.every((t=>!i.isMatchOngoing(t)))||s.push(...t.filter((t=>i.isMatchOngoing(t))))}return s}async seeding(t){const e=await this.storage.select("stage",t);if(!e)throw Error("Stage not found.");const n=t=>{if(null===t)return null;const{id:e,position:n}=t;return{id:e,position:n}};return"round_robin"===e.type?(await this.roundRobinSeeding(e)).map(n):(await this.eliminationSeeding(e)).map(n)}async finalStandings(t,e){const n=await this.storage.select("stage",t);if(!n)throw Error("Stage not found.");switch(n.type){case"round_robin":if(!e)throw Error("Computing the standings in a round-robin stage requires a ranking formula.");return this.roundRobinStandings(t,e);case"single_elimination":if(e)throw Error("Computing the standings in a single elimination stage with a ranking formula is not supported.");return this.singleEliminationStandings(t);case"double_elimination":if(e)throw Error("Computing the standings in a double elimination stage with a ranking formula is not supported.");return this.doubleEliminationStandings(t);default:throw Error("Unknown stage type.")}}async roundRobinSeeding(t){if(void 0===t.settings.size)throw Error("The size of the seeding is undefined.");const e=await this.storage.select("match",{stage_id:t.id});if(!e)throw Error("Error getting matches.");const n=i.convertMatchesToSeeding(e);if(n.length<t.settings.size){const e=t.settings.size-n.length;for(let t=0;t<e;t++)n.push(null)}const r=i.uniqueBy(n,(t=>t&&t.position));return i.setArraySize(r,t.settings.size,null)}async eliminationSeeding(t){const e=await this.storage.selectFirst("round",{stage_id:t.id,number:1},!1);if(!e)throw Error("Error getting the first round.");const n=await this.storage.select("match",{round_id:e.id});if(!n)throw Error("Error getting matches.");return i.convertMatchesToSeeding(n)}async roundRobinStandings(t,e){const n=await this.storage.select("match",{stage_id:t});if(!n)throw Error("Error getting matches.");return i.getRanking(n,e)}async singleEliminationStandings(t){var e;const n=[],{stage:r,group:o,match:a,participant:u}=await this.stageData(t),[c]=r,[l,d]=o,p=a.filter((t=>t.group_id===l.id)).pop();if(!p)throw Error("Final not found.");n[0]=[i.findParticipant(u,s(p))];const f=i.getLosers(u,a.filter((t=>t.group_id===l.id)));if(n.push(...f.reverse()),null===(e=c.settings)||void 0===e?void 0:e.consolationFinal){const t=a.filter((t=>t.group_id===d.id)).pop();if(!t)throw Error("Consolation final not found.");const e=i.findParticipant(u,s(t)),r=i.findParticipant(u,i.getLoser(t));n.splice(2,1,[e],[r])}return i.makeFinalStandings(n)}async doubleEliminationStandings(t){var e,n;const r=[],{stage:o,group:a,match:u,participant:c}=await this.stageData(t),[l]=o,[d,p,f]=a;if("none"===(null===(e=l.settings)||void 0===e?void 0:e.grandFinal)){const t=u.filter((t=>t.group_id===d.id)).pop();if(!t)throw Error("WB final not found.");const e=u.filter((t=>t.group_id===p.id)).pop();if(!e)throw Error("LB final not found.");r[0]=[i.findParticipant(c,s(t))],r[1]=[i.findParticipant(c,s(e))]}else{const t=u.filter((t=>t.group_id===f.id)),e=i.getGrandFinalDecisiveMatch((null===(n=l.settings)||void 0===n?void 0:n.grandFinal)||"none",t);r[0]=[i.findParticipant(c,s(e))],r[1]=[i.findParticipant(c,i.getLoser(e))]}const h=i.getLosers(c,u.filter((t=>t.group_id===p.id)));return r.push(...h.reverse()),i.makeFinalStandings(r)}async getStageSpecificData(t){const e=await this.storage.select("stage",t);if(!e)throw Error("Stage not found.");const n=await this.storage.select("group",{stage_id:t});if(!n)throw Error("Error getting groups.");const r=await this.storage.select("round",{stage_id:t});if(!r)throw Error("Error getting rounds.");const o=await this.storage.select("match",{stage_id:t});if(!o)throw Error("Error getting matches.");return{stage:e,groups:n,rounds:r,matches:o,matchGames:await this.matchGames(o)}}}e.Get=a;const s=t=>{const e=i.getWinner(t);if(!e)throw Error("The final match does not have a winner.");return e}},4487:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.setExtraFields=e.resetMatchResults=e.setMatchResults=e.getMatchStatus=e.hasBye=e.isMatchParticipantLocked=e.isMatchUpdateLocked=e.isMatchByeCompleted=e.isMatchWinCompleted=e.isMatchDrawCompleted=e.isMatchResultCompleted=e.isMatchForfeitCompleted=e.isMatchStale=e.isMatchOngoing=e.isMatchCompleted=e.isMatchStarted=e.isMatchPending=e.getOtherSide=e.getSide=e.isParticipantInMatch=e.findPosition=e.getMatchResult=e.byeLoser=e.byeWinnerToGrandFinal=e.byeWinner=e.getLoser=e.getWinner=e.toResultWithPosition=e.toResult=e.convertTBDtoBYE=e.ensureNotTied=e.ensureValidSize=e.isPowerOfTwo=e.fixSeeding=e.ensureEquallySized=e.ensureNoDuplicates=e.ensureEvenSized=e.makePairs=e.setArraySize=e.normalizeParticipant=e.makeNormalizedIdMapping=e.normalizeIds=e.balanceByes=e.makeGroups=e.assertRoundRobin=e.makeRoundRobinDistribution=e.makeRoundRobinMatches=e.splitByParity=e.splitBy=e.isDefined=void 0,e.getLowerBracketRoundCount=e.getLoserOrdering=e.getLoserCountFromWbForLbRound=e.getLoserRoundMatchCount=e.findLoserMatchNumber=e.isDoubleEliminationNecessary=e.getRoundPairCount=e.getUpperBracketRoundCount=e.isOrderingSupportedLoserBracket=e.isOrderingSupportedUpperBracket=e.ensureOrderingSupported=e.getSeedCount=e.getSeeds=e.getChildGamesResults=e.getUpdatedMatchResults=e.getParentMatchResults=e.setParentMatchCompleted=e.transitionToMinor=e.transitionToMajor=e.isMinorRound=e.isMajorRound=e.uniqueBy=e.getNonNull=e.sortSeeding=e.convertSlotsToSeeding=e.convertMatchesToSeeding=e.mapParticipantsToDatabase=e.mapParticipantsIdsToDatabase=e.mapParticipantsNamesToDatabase=e.extractParticipantsFromSeeding=e.isSeedingWithIds=e.setForfeits=e.setResults=e.setCompleted=e.getInferredResult=e.setScores=e.invertOpponents=e.handleGivenStatus=e.handleOpponentsInversion=e.resetNextOpponent=e.setNextOpponent=e.getNextSideConsolationFinalDoubleElimination=e.getNextSideLoserBracket=e.getNextSide=e.findParticipant=e.getGrandFinalDecisiveMatch=e.makeFinalStandings=e.getLosers=e.getOriginPosition=e.getOpponentId=void 0,e.getRanking=e.getFractionOfFinal=e.getMatchLocation=e.isFinalGroup=e.isLoserBracket=e.isWinnerBracket=e.isRoundCompleted=e.ensureNotRoundRobin=e.isRoundRobin=e.minScoreToWinBestOfX=e.getNearestPowerOfTwo=e.getDiagonalMatchNumber=void 0;const r=n(7021),o=n(2644);function i(t){return null!=t}function a(t){const e=t.length,n=e%2==0?e:e+1,r=n-1,o=n/2,i=[];for(let a=0;a<r;a++){const r=[];for(let i=0;i<o;i++){if(0===i&&e%2==1)continue;const o=[(a-i-1+n)%(n-1),0===i?n-1:(a+i)%(n-1)];r.push([t[o[0]],t[o[1]]])}i.push(r)}return i}function s(t){let e=0;return t.reduce(((t,n)=>({...t,[n.id]:e++})),{})}function u(t,e){return null===t?null:{...t,id:null!==t.id?e[t.id]:null}}function c(t,e,n){return Array.from({length:e},((e,r)=>t[r]||n))}function l(t){return Number.isInteger(Math.log2(t))}function d(t){const e=f(t);return e?t[g(e)]:null}function p(t){return null===t[0]&&null===t[1]?null:null===t[0]&&null!==t[1]?{id:t[1].id}:null!==t[0]&&null===t[1]?{id:t[0].id}:{id:null}}function f(t){var e,n;if(!v(t))return null;if(w(t))return null;if(null===t.opponent1&&null===t.opponent2)return null;let r=null;if(("win"===(null===(e=t.opponent1)||void 0===e?void 0:e.result)||null===t.opponent2||t.opponent2.forfeit)&&(r="opponent1"),"win"===(null===(n=t.opponent2)||void 0===n?void 0:n.result)||null===t.opponent1||t.opponent1.forfeit){if(null!==r)throw Error("There are two winners.");r="opponent2"}return r}function h(t){return t%2==1?"opponent1":"opponent2"}function g(t){return"opponent1"===t?"opponent2":"opponent1"}function m(t){var e,n;return void 0!==(null===(e=t.opponent1)||void 0===e?void 0:e.score)||void 0!==(null===(n=t.opponent2)||void 0===n?void 0:n.score)}function v(t){return S(t)||b(t)||y(t)}function b(t){var e,n;return void 0!==(null===(e=t.opponent1)||void 0===e?void 0:e.forfeit)||void 0!==(null===(n=t.opponent2)||void 0===n?void 0:n.forfeit)}function y(t){return w(t)||k(t)}function w(t){var e,n;return"draw"===(null===(e=t.opponent1)||void 0===e?void 0:e.result)&&"draw"===(null===(n=t.opponent2)||void 0===n?void 0:n.result)}function k(t){var e,n,r,o;return"win"===(null===(e=t.opponent1)||void 0===e?void 0:e.result)||"win"===(null===(n=t.opponent2)||void 0===n?void 0:n.result)||"loss"===(null===(r=t.opponent1)||void 0===r?void 0:r.result)||"loss"===(null===(o=t.opponent2)||void 0===o?void 0:o.result)}function S(t){var e,n;return null===t.opponent1&&null!==(null===(e=t.opponent2)||void 0===e?void 0:e.id)||null===t.opponent2&&null!==(null===(n=t.opponent1)||void 0===n?void 0:n.id)||null===t.opponent1&&null===t.opponent2}function M(t){return null===t.opponent1||null===t.opponent2}function O(t){var e,n,o,i;const a=Array.isArray(t)?{opponent1:t[0],opponent2:t[1]}:t;return M(a)||null===(null===(e=a.opponent1)||void 0===e?void 0:e.id)&&null===(null===(n=a.opponent2)||void 0===n?void 0:n.id)?r.Status.Locked:null===(null===(o=a.opponent1)||void 0===o?void 0:o.id)||null===(null===(i=a.opponent2)||void 0===i?void 0:i.id)?r.Status.Waiting:v(a)?r.Status.Completed:m(a)?r.Status.Running:r.Status.Ready}function _(t){t.opponent1&&(t.opponent1.forfeit=void 0,t.opponent1.result=void 0),t.opponent2&&(t.opponent2.forfeit=void 0,t.opponent2.result=void 0),t.status=O(t)}function E(t,e){const n=(t,e,n)=>{t&&e&&Object.keys(e).filter((t=>!n.includes(t))).forEach((n=>{t[n]=e[n]}))},r=["id","score","position","forfeit","result"];n(t,e,["id","number","stage_id","group_id","round_id","status","opponent1","opponent2","child_count","parent_id"]),n(t.opponent1,e.opponent1,r),n(t.opponent2,e.opponent2,r)}function x(t,e){const n=t[e];return n&&n.id}function R(t,e){if(!e)throw Error("Cannot find a BYE participant.");const n=t.find((t=>t.id===(null==e?void 0:e.id)));if(!n)throw Error("Participant not found.");return n}function P(t,e){var n,r,o,a;const s=null===(n=e.opponent1)||void 0===n?void 0:n.id,u=null===(r=e.opponent2)||void 0===r?void 0:r.id,c=null===(o=t.opponent1)||void 0===o?void 0:o.id,l=null===(a=t.opponent2)||void 0===a?void 0:a.id;if(i(s)&&s!==c&&s!==l)throw Error("The given opponent1 ID does not exist in this match.");if(i(u)&&u!==c&&u!==l)throw Error("The given opponent2 ID does not exist in this match.");(i(s)&&s===l||i(u)&&u===c)&&L(e)}function C(t,e){var n,o,i,a;if(e.status===r.Status.Running)null===(n=t.opponent1)||void 0===n||delete n.result,null===(o=t.opponent2)||void 0===o||delete o.result,t.status=r.Status.Running;else if(e.status===r.Status.Completed){if(void 0===(null===(i=e.opponent1)||void 0===i?void 0:i.score)||void 0===(null===(a=e.opponent2)||void 0===a?void 0:a.score))return;e.opponent1.score>e.opponent2.score?e.opponent1.result="win":e.opponent2.score>e.opponent1.score?e.opponent2.result="win":(e.opponent1.result="draw",e.opponent2.result="draw"),t.status=r.Status.Completed}}function L(t){[t.opponent1,t.opponent2]=[t.opponent2,t.opponent1]}function N(t,e){var n,o,i,a;if((null===(n=e.opponent1)||void 0===n?void 0:n.score)===(null===(o=t.opponent1)||void 0===o?void 0:o.score)&&(null===(i=e.opponent2)||void 0===i?void 0:i.score)===(null===(a=t.opponent2)||void 0===a?void 0:a.score))return!1;const s=t.status;return t.status=r.Status.Running,e.opponent1&&t.opponent1&&(t.opponent1.score=e.opponent1.score),e.opponent2&&t.opponent2&&(t.opponent2.score=e.opponent2.score),t.status!==s}function j(t,e){return t&&!e?{opponent1:{...t,result:"win"},opponent2:null}:!t&&e?{opponent1:null,opponent2:{...e,result:"win"}}:{opponent1:t,opponent2:e}}function F(t,e,n){t.status=r.Status.Completed,B(t,e,"win","loss",n),B(t,e,"loss","win",n),B(t,e,"draw","draw",n);const{opponent1:o,opponent2:i}=j(t.opponent1,t.opponent2);t.opponent1=o,t.opponent2=i,D(t,e)}function B(t,e,n,r,o){var i,a;if(e.opponent1&&e.opponent2){if("win"===e.opponent1.result&&"win"===e.opponent2.result)throw Error("There are two winners.");if("loss"===e.opponent1.result&&"loss"===e.opponent2.result)throw Error("There are two losers.");if(!o&&!0===e.opponent1.forfeit&&!0===e.opponent2.forfeit)throw Error("There are two forfeits.")}(null===(i=e.opponent1)||void 0===i?void 0:i.result)===n&&(t.opponent1?t.opponent1.result=n:t.opponent1={id:null,result:n},t.opponent2?t.opponent2.result=r:t.opponent2={id:null,result:r}),(null===(a=e.opponent2)||void 0===a?void 0:a.result)===n&&(t.opponent2?t.opponent2.result=n:t.opponent2={id:null,result:n},t.opponent1?t.opponent1.result=r:t.opponent1={id:null,result:r})}function D(t,e){var n,r,o,i;if(!0===(null===(n=e.opponent1)||void 0===n?void 0:n.forfeit)&&!0===(null===(r=e.opponent2)||void 0===r?void 0:r.forfeit))return t.opponent1&&(t.opponent1.forfeit=!0),void(t.opponent2&&(t.opponent2.forfeit=!0));!0===(null===(o=e.opponent1)||void 0===o?void 0:o.forfeit)&&(t.opponent1&&(t.opponent1.forfeit=!0),t.opponent2?t.opponent2.result="win":t.opponent2={id:null,result:"win"}),!0===(null===(i=e.opponent2)||void 0===i?void 0:i.forfeit)&&(t.opponent2&&(t.opponent2.forfeit=!0),t.opponent1?t.opponent1.result="win":t.opponent1={id:null,result:"win"})}function I(t,e,n,r){const o=e.map(((e,r)=>{if(null===e)return null;const o=n.find((n=>"object"==typeof e?n[t]===e[t]:n[t]===e));if(!o)throw Error(`Participant ${t} not found in database.`);return{id:o.id,position:r+1}}));if(!r)return o;if(r.length!==o.length)throw Error("Not enough seeds in at least one group of the manual ordering.");return r.map((t=>o[t-1]))}function T(t){const e=t.filter((t=>null!==t));if(e.sort(((t,e)=>t.position-e.position)),e.length===t.length)return e;const n=Object.fromEntries(e.map((t=>[t.position-1,t])));return Array.from({length:t.length},((t,e)=>n[e]||null))}function A(t){return t.filter((t=>null!==t))}function U(t){return t%2==1}function G(t){return!U(t)}function $(t,e,n,r){return W(t,e,n),1===e?2*r:r}function W(t,e,n){if(t&&!H(e,n))throw Error("This round does not support ordering.");if(!t&&!z(e))throw Error("This round does not support ordering.")}function z(t){return 1===t}function H(t,e){return 1===t||G(t)&&t<e}function V(t){return Math.log2(t)}function q(t){return V(t)-1}function K(t,e){const n=Math.ceil(e/2)-1,r=q(t),o=Math.pow(2,r-n-1);if(0===e)throw Error("Round number must start at 1.");if(o<1)throw Error(`Round number ${e} is too big for a loser bracket in a stage of ${t} participants.`);return o}function J(t,e){const n=K(t,e);return 1===e?2*n:n}function Y(t){return Math.pow(2,Math.ceil(Math.log2(t)))}function Q(t){return(t+1)/2}function X(t){return"round_robin"===t.type}function Z(t,e){return"double_elimination"===t&&1===e}function tt(t,e){return"double_elimination"===t&&2===e}function et(t,e){return"single_elimination"===t&&2===e||"double_elimination"===t&&3===e}function nt(t,e,n,r){if(!n||null===n.id)return;const o=t[n.id]||{rank:0,id:0,played:0,wins:0,draws:0,losses:0,forfeits:0,scoreFor:0,scoreAgainst:0,scoreDifference:0,points:0};o.id=n.id,(n.forfeit||n.result)&&o.played++,"win"===n.result&&o.wins++,"draw"===n.result&&o.draws++,"loss"===n.result&&o.losses++,n.forfeit&&o.forfeits++,o.scoreFor+=n.score||0,o.scoreAgainst+=r&&r.score||0,o.scoreDifference=o.scoreFor-o.scoreAgainst,o.points=e(o),t[n.id]=o}e.isDefined=i,e.splitBy=function(t,e){const n={};for(const r of t){const t=r[e];n[t]||(n[t]=[]),n[t].push(r)}return Object.values(n)},e.splitByParity=function(t){return{even:t.filter(((t,e)=>e%2==0)),odd:t.filter(((t,e)=>e%2==1))}},e.makeRoundRobinMatches=function(t,e="simple"){const n=a(t);if("simple"===e)return n;const r=n.map((t=>[...t].reverse())).reverse();return[...n,...r]},e.makeRoundRobinDistribution=a,e.assertRoundRobin=function(t,e){const n=t.length,r=Math.floor(n/2),o=n%2==0?n-1:n;if(e.length!==o)throw Error("Round count is wrong");if(!e.every((t=>t.length===r)))throw Error("Not every round has the good number of matches");const i=Object.fromEntries(t.map((t=>[t,new Set])));for(const t of e){const e=new Set;for(const n of t){if(2!==n.length)throw Error("One match is not a pair");if(e.has(n[0]))throw Error("This team is already playing");if(e.add(n[0]),e.has(n[1]))throw Error("This team is already playing");if(e.add(n[1]),i[n[0]].has(n[1]))throw Error("The team has already matched this team");if(i[n[0]].add(n[1]),i[n[1]].has(n[0]))throw Error("The team has already matched this team");i[n[1]].add(n[0])}}},e.makeGroups=function(t,e){const n=Math.ceil(t.length/e),r=[];for(let e=0;e<t.length;e++)e%n==0&&r.push([]),r[r.length-1].push(t[e]);return r},e.balanceByes=function(t,e){if(t=t.filter((t=>null!==t)),e=e||Y(t.length),t.length<e/2)return c(t.flatMap((t=>[t,null])),e,null);const n=t.length,r=e-n,o=t.slice(0,n-r).filter(((t,e)=>e%2==0)).map(((e,n)=>[t[2*n],t[2*n+1]])),i=t.slice(n-r,n).map((t=>[t,null]));return c([...o.flat(),...i.flat()],e,null)},e.normalizeIds=function(t){const e={participant:s(t.participant),stage:s(t.stage),group:s(t.group),round:s(t.round),match:s(t.match),match_game:s(t.match_game)};return{participant:t.participant.map((t=>({...t,id:e.participant[t.id]}))),stage:t.stage.map((t=>({...t,id:e.stage[t.id]}))),group:t.group.map((t=>({...t,id:e.group[t.id],stage_id:e.stage[t.stage_id]}))),round:t.round.map((t=>({...t,id:e.round[t.id],stage_id:e.stage[t.stage_id],group_id:e.group[t.group_id]}))),match:t.match.map((t=>({...t,id:e.match[t.id],stage_id:e.stage[t.stage_id],group_id:e.group[t.group_id],round_id:e.round[t.round_id],opponent1:u(t.opponent1,e.participant),opponent2:u(t.opponent2,e.participant)}))),match_game:t.match_game.map((t=>({...t,id:e.match_game[t.id],stage_id:e.stage[t.stage_id],parent_id:e.match[t.parent_id],opponent1:u(t.opponent1,e.participant),opponent2:u(t.opponent2,e.participant)})))}},e.makeNormalizedIdMapping=s,e.normalizeParticipant=u,e.setArraySize=c,e.makePairs=function(t){return t.map(((e,n)=>n%2==0?[t[n],t[n+1]]:[])).filter((t=>2===t.length))},e.ensureEvenSized=function(t){if(t.length%2==1)throw Error("Array size must be even.")},e.ensureNoDuplicates=function(t){const e=A(t);if(e.filter(((t,n)=>{const r=JSON.stringify(t);return e.findIndex((t=>JSON.stringify(t)===r))===n})).length<e.length)throw new Error("The seeding has a duplicate participant.")},e.ensureEquallySized=function(t,e){if(t.length!==e.length)throw Error("Arrays' size must be equal.")},e.fixSeeding=function(t,e){if(t.length>e)throw Error("The seeding has more participants than the size of the stage.");return t.length<e?c(t,e,null):t},e.isPowerOfTwo=l,e.ensureValidSize=function(t,e){if(0===e)throw Error("Impossible to create an empty stage. If you want an empty seeding, just set the size of the stage.");if(e<2)throw Error("Impossible to create a stage with less than 2 participants.");if("round_robin"!==t&&!l(e))throw Error("The library only supports a participant count which is a power of two.")},e.ensureNotTied=function(t){if(t[0]===t[1])throw Error(`${t[0]} and ${t[1]} are tied. It cannot be.`)},e.convertTBDtoBYE=function(t){return null===t||null===(null==t?void 0:t.id)?null:t},e.toResult=function(t){return t&&{id:t.id}},e.toResultWithPosition=function(t){return t&&{id:t.id,position:t.position}},e.getWinner=function(t){const e=f(t);return e?t[e]:null},e.getLoser=d,e.byeWinner=p,e.byeWinnerToGrandFinal=function(t){const e=p(t);return e&&(e.position=1),e},e.byeLoser=function(t,e){return null===t[0]||null===t[1]?null:{id:null,position:e+1}},e.getMatchResult=f,e.findPosition=function(t,e){var n,r;for(const o of t){if((null===(n=o.opponent1)||void 0===n?void 0:n.position)===e)return o.opponent1;if((null===(r=o.opponent2)||void 0===r?void 0:r.position)===e)return o.opponent2}return null},e.isParticipantInMatch=function(t,e){return[t.opponent1,t.opponent2].some((t=>(null==t?void 0:t.id)===e))},e.getSide=h,e.getOtherSide=g,e.isMatchPending=function(t){var e,n;return!(null===(e=t.opponent1)||void 0===e?void 0:e.id)||!(null===(n=t.opponent2)||void 0===n?void 0:n.id)},e.isMatchStarted=m,e.isMatchCompleted=v,e.isMatchOngoing=function(t){return[r.Status.Ready,r.Status.Running].includes(t.status)},e.isMatchStale=function(t){return t.status>=r.Status.Completed||S(t)},e.isMatchForfeitCompleted=b,e.isMatchResultCompleted=y,e.isMatchDrawCompleted=w,e.isMatchWinCompleted=k,e.isMatchByeCompleted=S,e.isMatchUpdateLocked=function(t){return t.status===r.Status.Locked||t.status===r.Status.Waiting||t.status===r.Status.Archived||S(t)},e.isMatchParticipantLocked=function(t){return t.status>=r.Status.Running},e.hasBye=M,e.getMatchStatus=O,e.setMatchResults=function(t,e,n){var r,o;if(C(t,e),!n&&("draw"===(null===(r=e.opponent1)||void 0===r?void 0:r.result)||"draw"===(null===(o=e.opponent2)||void 0===o?void 0:o.result)))throw Error("Having a draw is forbidden in an elimination tournament.");const i=v(e),a=v(t);E(t,e),P(t,e);const s=N(t,e);return i&&a?(F(t,e,n),{statusChanged:!1,resultChanged:!0}):i&&!a?(F(t,e,n),{statusChanged:!0,resultChanged:!0}):!i&&a?(_(t),{statusChanged:!0,resultChanged:!0}):{statusChanged:s,resultChanged:!1}},e.resetMatchResults=_,e.setExtraFields=E,e.getOpponentId=x,e.getOriginPosition=function(t,e){var n;const r=null===(n=t[e])||void 0===n?void 0:n.position;if(void 0===r)throw Error("Position is undefined.");return r},e.getLosers=function(t,e){const n=[];let r=null,o=-1;for(const i of e){i.round_id!==r&&(r=i.round_id,o++,n[o]=[]);const e=d(i);null!==e&&n[o].push(R(t,e))}return n},e.makeFinalStandings=function(t){const e=[];let n=1;for(const r of t){for(const t of r)e.push({id:t.id,name:t.name,rank:n});n++}return e},e.getGrandFinalDecisiveMatch=function(t,e){if("simple"===t)return e[0];if("double"===t)return"opponent2"===f(e[0])?e[1]:e[0];throw Error("The Grand Final is disabled.")},e.findParticipant=R,e.getNextSide=function(t,e,n,r){return"loser_bracket"===r&&e%2==1||"loser_bracket"===r&&e===n?"opponent2":h(t)},e.getNextSideLoserBracket=function(t,e,n){var r;return n>1||(null===(r=e.opponent1)||void 0===r?void 0:r.position)===t?"opponent1":"opponent2"},e.getNextSideConsolationFinalDoubleElimination=function(t){return U(t)?"opponent1":"opponent2"},e.setNextOpponent=function(t,e,n,r){var o;t[e]=n[r]&&{id:x(n,r),position:null===(o=t[e])||void 0===o?void 0:o.position},t.status=O(t)},e.resetNextOpponent=function(t,e){var n;t[e]=t[e]&&{id:null,position:null===(n=t[e])||void 0===n?void 0:n.position},t.status=r.Status.Locked},e.handleOpponentsInversion=P,e.handleGivenStatus=C,e.invertOpponents=L,e.setScores=N,e.getInferredResult=j,e.setCompleted=F,e.setResults=B,e.setForfeits=D,e.isSeedingWithIds=function(t){return t.some((t=>"number"==typeof t))},e.extractParticipantsFromSeeding=function(t,e){return e.filter((t=>null!==t)).map((e=>"string"==typeof e?{tournament_id:t,name:e}:{...e,tournament_id:t,name:e.name}))},e.mapParticipantsNamesToDatabase=function(t,e,n){return I("name",t,e,n)},e.mapParticipantsIdsToDatabase=function(t,e,n){return I("id",t,e,n)},e.mapParticipantsToDatabase=I,e.convertMatchesToSeeding=function(t){return T([].concat(...t.map((t=>[t.opponent1,t.opponent2]))))},e.convertSlotsToSeeding=function(t){return t.map((t=>null===t||null===t.id?null:t.id))},e.sortSeeding=T,e.getNonNull=A,e.uniqueBy=function(t,e){const n=new Set;return t.filter((t=>{const r=e(t);return!r||!n.has(r)&&(n.add(r),!0)}))},e.isMajorRound=U,e.isMinorRound=G,e.transitionToMajor=function(t){const e=t.length/2,n=[];for(let r=0;r<e;r++){const e=2*r;n.push([p(t[e]),p(t[e+1])])}return n},e.transitionToMinor=function(t,e,n){const r=n?o.ordering[n](e):e,i=t.length,a=[];for(let e=0;e<i;e++){const n=e;a.push([r[n],p(t[n])])}return a},e.setParentMatchCompleted=function(t,e,n){var r,o;if(void 0===(null===(r=t.opponent1)||void 0===r?void 0:r.score)||void 0===(null===(o=t.opponent2)||void 0===o?void 0:o.score))throw Error("Either opponent1, opponent2 or their scores are falsy.");const i=Q(e);if(t.opponent1.score>=i)t.opponent1.result="win";else if(t.opponent2.score>=i)t.opponent2.result="win";else if(t.opponent1.score===t.opponent2.score&&t.opponent1.score+t.opponent2.score>e-1){if(n)return t.opponent1.result="draw",void(t.opponent2.result="draw");throw Error("Match games result in a tie for the parent match.")}},e.getParentMatchResults=function(t,e){return{opponent1:{id:t.opponent1&&t.opponent1.id,score:e.opponent1},opponent2:{id:t.opponent2&&t.opponent2.id,score:e.opponent2}}},e.getUpdatedMatchResults=function(t,e,n){return{...e,...t,...n?{opponent1:null===t.opponent1?null:{...e.opponent1,...t.opponent1},opponent2:null===t.opponent2?null:{...e.opponent2,...t.opponent2}}:{opponent1:null===t.opponent1?{id:null}:{...e.opponent1,...t.opponent1},opponent2:null===t.opponent2?{id:null}:{...e.opponent2,...t.opponent2}}}},e.getChildGamesResults=function(t){const e={opponent1:0,opponent2:0};for(const n of t){const t=f(n);"opponent1"===t?e.opponent1++:"opponent2"===t&&e.opponent2++}return e},e.getSeeds=function(t,e,n,r){const o=$(t,e,n,r);return Array.from({length:o},((t,e)=>e+1))},e.getSeedCount=$,e.ensureOrderingSupported=W,e.isOrderingSupportedUpperBracket=z,e.isOrderingSupportedLoserBracket=H,e.getUpperBracketRoundCount=V,e.getRoundPairCount=q,e.isDoubleEliminationNecessary=function(t){return t>2},e.findLoserMatchNumber=function(t,e,n,r){const i=J(t,e),a=Array.from({length:i},((t,e)=>e+1)),s=(r?o.ordering[r](a):a).indexOf(n)+1;return 1===e?Math.ceil(s/2):s},e.getLoserRoundMatchCount=K,e.getLoserCountFromWbForLbRound=J,e.getLoserOrdering=function(t,e){return t[1+Math.floor(e/2)]},e.getLowerBracketRoundCount=function(t){return 2*q(t)},e.getDiagonalMatchNumber=function(t){return Math.ceil(t/2)},e.getNearestPowerOfTwo=Y,e.minScoreToWinBestOfX=Q,e.isRoundRobin=X,e.ensureNotRoundRobin=function(t){if(X(t))throw Error("Impossible to update ordering in a round-robin stage.")},e.isRoundCompleted=function(t){return t.every((t=>t.status>=r.Status.Completed))},e.isWinnerBracket=Z,e.isLoserBracket=tt,e.isFinalGroup=et,e.getMatchLocation=function(t,e){return Z(t,e)?"winner_bracket":tt(t,e)?"loser_bracket":et(t,e)?"final_group":"single_bracket"},e.getFractionOfFinal=function(t,e){if(t>e)throw Error(`There are more rounds than possible. ${JSON.stringify({roundNumber:t,roundCount:e})}`);return 1/Math.pow(2,e-t)},e.getRanking=function(t,e){const n={};for(const r of t)nt(n,e,r.opponent1,r.opponent2),nt(n,e,r.opponent2,r.opponent1);return function(t){const e=Object.values(t).sort(((t,e)=>t.points!==e.points?e.points-t.points:t.played!==e.played?e.played-t.played:e.scoreDifference-t.scoreDifference)),n={value:0,lastPoints:-1};for(const t of e)t.rank=n.lastPoints!==t.points?++n.value:n.value,n.lastPoints=t.points;return e}(n)}},9037:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.StageCreator=e.Delete=e.Reset=e.Find=e.Update=e.Get=e.ordering=e.helpers=e.BracketsManager=void 0;var r=n(6076);Object.defineProperty(e,"BracketsManager",{enumerable:!0,get:function(){return r.BracketsManager}}),e.helpers=n(4487);var o=n(2644);Object.defineProperty(e,"ordering",{enumerable:!0,get:function(){return o.ordering}});var i=n(3576);Object.defineProperty(e,"Get",{enumerable:!0,get:function(){return i.Get}});var a=n(2011);Object.defineProperty(e,"Update",{enumerable:!0,get:function(){return a.Update}});var s=n(4063);Object.defineProperty(e,"Find",{enumerable:!0,get:function(){return s.Find}});var u=n(5369);Object.defineProperty(e,"Reset",{enumerable:!0,get:function(){return u.Reset}});var c=n(4378);Object.defineProperty(e,"Delete",{enumerable:!0,get:function(){return c.Delete}});var l=n(4267);Object.defineProperty(e,"StageCreator",{enumerable:!0,get:function(){return l.StageCreator}})},6076:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.BracketsManager=void 0;const r=n(9765),o=n(3576),i=n(2011),a=n(4378),s=n(4063),u=n(5369),c=n(7429),l=n(4487);e.BracketsManager=class{constructor(t,e){this.verbose=!1,this.verbose=null!=e&&e,this.storage=t,this.instrumentStorage(),this.storage.selectFirst=async(t,e,n=!0)=>{var r;const o=await this.storage.select(t,e);if(!o||0===o.length)return null;if(n&&o.length>1)throw Error(`Selecting ${JSON.stringify(e)} on table "${t}" must return a unique value.`);return null!==(r=o[0])&&void 0!==r?r:null},this.storage.selectLast=async(t,e,n=!0)=>{var r;const o=await this.storage.select(t,e);if(!o||0===o.length)return null;if(n&&o.length>1)throw Error(`Selecting ${JSON.stringify(e)} on table "${t}" must return a unique value.`);return null!==(r=o[o.length-1])&&void 0!==r?r:null};const n=new r.Create(this.storage).stage.bind(this);this.create=Object.assign(n,{stage:n}),this.get=new o.Get(this.storage),this.update=new i.Update(this.storage),this.delete=new a.Delete(this.storage),this.find=new s.Find(this.storage),this.reset=new u.Reset(this.storage)}async import(t,e=!1){if(e&&(t=l.normalizeIds(t)),!await this.storage.delete("participant"))throw Error("Could not empty the participant table.");if(!await this.storage.insert("participant",t.participant))throw Error("Could not import participants.");if(!await this.storage.delete("stage"))throw Error("Could not empty the stage table.");if(!await this.storage.insert("stage",t.stage))throw Error("Could not import stages.");if(!await this.storage.delete("group"))throw Error("Could not empty the group table.");if(!await this.storage.insert("group",t.group))throw Error("Could not import groups.");if(!await this.storage.delete("round"))throw Error("Could not empty the round table.");if(!await this.storage.insert("round",t.round))throw Error("Could not import rounds.");if(!await this.storage.delete("match"))throw Error("Could not empty the match table.");if(!await this.storage.insert("match",t.match))throw Error("Could not import matches.");if(!await this.storage.delete("match_game"))throw Error("Could not empty the match_game table.");if(!await this.storage.insert("match_game",t.match_game))throw Error("Could not import match games.")}async export(){const t=await this.storage.select("participant");if(!t)throw Error("Error getting participants.");const e=await this.storage.select("stage");if(!e)throw Error("Error getting stages.");const n=await this.storage.select("group");if(!n)throw Error("Error getting groups.");const r=await this.storage.select("round");if(!r)throw Error("Error getting rounds.");const o=await this.storage.select("match");if(!o)throw Error("Error getting matches.");return{participant:t,stage:e,group:n,round:r,match:o,match_game:await this.get.matchGames(o)}}instrumentStorage(){const t=this.storage,e=["insert","select","update","delete"];for(const n of Object.getOwnPropertyNames(Object.getPrototypeOf(t))){if(!e.includes(n))continue;const r=t[n].bind(t);t[n]=async(t,...e)=>{const o=this.verbose;let i,a;o&&(i=(0,c.v4)(),a=Date.now(),console.log(`${i} ${n.toUpperCase()} "${t}" args: ${JSON.stringify(e)}`));const s=await r(t,...e);if(o){const t=Date.now()-a;console.log(`${i} ${t}ms - Returned ${JSON.stringify(s)}`)}return s}}}}},2644:function(t,e){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.defaultMinorOrdering=e.ordering=void 0,e.ordering={natural:t=>[...t],reverse:t=>[...t].reverse(),half_shift:t=>[...t.slice(t.length/2),...t.slice(0,t.length/2)],reverse_half_shift:t=>[...t.slice(0,t.length/2).reverse(),...t.slice(t.length/2).reverse()],pair_flip:t=>{const e=[];for(let n=0;n<t.length;n+=2)e.push(t[n+1],t[n]);return e},inner_outer:t=>{if(2===t.length)return t;const e=t.length;let n=[1,2];for(;n.length<e;){const t=2*n.length,e=[];for(const r of n)e.push(r,t+1-r);n=e}const r=[];for(const e of n)r.push(t[e-1]);return r},"groups.effort_balanced":(t,e)=>{const n=[];let r=0,o=0;for(;n.length<t.length;)n.push(t[r]),r+=e,r>=t.length&&(r=++o);return n},"groups.seed_optimized":(t,e)=>{const n=Array.from({length:e},(t=>[]));for(let r=0;r<t.length/e;r++)if(r%2==0)for(let o=0;o<e;o++)n[o].push(t[r*e+o]);else for(let o=0;o<e;o++)n[e-o-1].push(t[r*e+o]);return n.flat()},"groups.bracket_optimized":(t,n)=>{if(n<2)return[...t];if(n%2==1)return e.ordering["groups.seed_optimized"](t,n);const r=t.length,o=n/2;let i=[1,2];for(;i.length<r;){const t=2*i.length,e=[];for(const n of i)e.push(n,t+1-n);i=e}const a=t=>{const e=t%o,r=Math.floor(t/o),i=Math.floor(r/2)%2==1;return r%2==0?i?o-1-e:e:i?o+e:n-1-e},s=Array.from({length:n},(()=>[])),u=Math.floor(i.length/2);for(let e=0;e<u;e++){const n=a(e),r=i[2*e]-1;s[n].push(t[r])}for(let e=0;e<u;e++){const r=a(e),u=i[2*e+1]-1;s[(r+o)%n].push(t[u])}const c=new Map(t.map(((t,e)=>[t,e])));for(const t of s)t.sort(((t,e)=>c.get(t)-c.get(e)));return s.flat()}},e.defaultMinorOrdering={4:["natural","reverse"],8:["natural","reverse","natural"],16:["natural","reverse_half_shift","reverse","natural"],32:["natural","reverse","half_shift","natural","natural"],64:["natural","reverse","half_shift","reverse","natural","natural"],128:["natural","reverse","half_shift","pair_flip","pair_flip","pair_flip","natural"]}},5369:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Reset=void 0;const r=n(7021),o=n(3517),i=n(4487);class a extends o.BaseUpdater{async matchResults(t){const e=await this.storage.select("match",t);if(!e)throw Error("Match not found.");if(!i.isMatchForfeitCompleted(e)&&e.child_count>0)throw Error("The parent match is controlled by its child games and its result cannot be reset.");const n=await this.storage.select("stage",e.stage_id);if(!n)throw Error("Stage not found.");const o=await this.storage.select("group",e.group_id);if(!o)throw Error("Group not found.");const{roundNumber:a,roundCount:s}=await this.getRoundPositionalInfo(e.round_id),u=i.getMatchLocation(n.type,o.number);if((await this.getNextMatches(e,u,n,a,s)).some((t=>t&&t.status>=r.Status.Running&&!i.isMatchByeCompleted(t))))throw Error("The match is locked.");i.resetMatchResults(e),await this.applyMatchUpdate(e),i.isRoundRobin(n)||await this.updateRelatedMatches(e,!0,!0)}async matchGameResults(t){const e=await this.storage.select("match_game",t);if(!e)throw Error("Match game not found.");const n=await this.storage.select("stage",e.stage_id);if(!n)throw Error("Stage not found.");const r=i.isRoundRobin(n);if(i.resetMatchResults(e),!await this.storage.update("match_game",e.id,e))throw Error("Could not update the match game.");await this.updateParentMatch(e.parent_id,r)}async seeding(t){await this.updateSeeding(t,{seeding:null},!1)}}e.Reset=a},2011:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.Update=void 0;const r=n(7021),o=n(2644),i=n(3517),a=n(4487);class s extends i.BaseUpdater{async match(t){if(void 0===t.id)throw Error("No match id given.");const e=await this.storage.select("match",t.id);if(!e)throw Error("Match not found.");await this.updateMatch(e,t)}async matchGame(t){const e=await this.findMatchGame(t);await this.updateMatchGame(e,t)}async ordering(t,e){const n=await this.storage.select("stage",t);if(!n)throw Error("Stage not found.");a.ensureNotRoundRobin(n);const r=await this.getOrderedRounds(n);if(e.length!==r.length)throw Error("The count of seed orderings is incorrect.");for(let t=0;t<r.length;t++)await this.updateRoundOrdering(r[t],e[t])}async roundOrdering(t,e){const n=await this.storage.select("round",t);if(!n)throw Error("This round does not exist.");const r=await this.storage.select("stage",n.stage_id);if(!r)throw Error("Stage not found.");a.ensureNotRoundRobin(r),await this.updateRoundOrdering(n,e)}async matchChildCount(t,e,n){switch(t){case"stage":await this.updateStageMatchChildCount(e,n);break;case"group":await this.updateGroupMatchChildCount(e,n);break;case"round":await this.updateRoundMatchChildCount(e,n);break;case"match":const t=await this.storage.select("match",e);if(!t)throw Error("Match not found.");await this.adjustMatchChildGames(t,n);break;default:throw Error("Unknown child count level.")}}async seeding(t,e,n=!1){await this.updateSeeding(t,{seeding:e},n)}async seedingIds(t,e,n=!1){await this.updateSeeding(t,{seedingIds:e},n)}async confirmSeeding(t){await this.confirmCurrentSeeding(t)}async updateRoundOrdering(t,e){const n=await this.storage.select("match",{round_id:t.id});if(!n)throw Error("This round has no match.");if(n.some((t=>t.status>r.Status.Ready)))throw Error("At least one match has started or is completed.");const i=await this.storage.select("stage",t.stage_id);if(!i)throw Error("Stage not found.");if(void 0===i.settings.size)throw Error("Undefined stage size.");const s=await this.storage.select("group",t.group_id);if(!s)throw Error("Group not found.");const u=a.isLoserBracket(i.type,s.number),c=a.getLowerBracketRoundCount(i.settings.size),l=a.getSeeds(u,t.number,c,n.length),d=o.ordering[e](l);await this.applyRoundOrdering(t.number,n,d)}async updateStageMatchChildCount(t,e){if(!await this.storage.update("match",{stage_id:t},{child_count:e}))throw Error("Could not update the match.");const n=await this.storage.select("match",{stage_id:t});if(!n)throw Error("This stage has no match.");for(const t of n)await this.adjustMatchChildGames(t,e)}async updateGroupMatchChildCount(t,e){if(!await this.storage.update("match",{group_id:t},{child_count:e}))throw Error("Could not update the match.");const n=await this.storage.select("match",{group_id:t});if(!n)throw Error("This group has no match.");for(const t of n)await this.adjustMatchChildGames(t,e)}async updateRoundMatchChildCount(t,e){if(!await this.storage.update("match",{round_id:t},{child_count:e}))throw Error("Could not update the match.");const n=await this.storage.select("match",{round_id:t});if(!n)throw Error("This round has no match.");for(const t of n)await this.adjustMatchChildGames(t,e)}async applyRoundOrdering(t,e,n){for(const r of e){const o={...r};if(o.opponent1=a.findPosition(e,n.shift()),1===t&&(o.opponent2=a.findPosition(e,n.shift())),!await this.storage.update("match",o.id,o))throw Error("Could not update the match.")}}async adjustMatchChildGames(t,e){const n=await this.storage.select("match_game",{parent_id:t.id});let r=n?n.length:0;for(;r<e;){if(-1===await this.storage.insert("match_game",{number:r+1,stage_id:t.stage_id,parent_id:t.id,status:t.status,opponent1:{id:null},opponent2:{id:null}}))throw Error("Could not adjust the match games when inserting.");r++}for(;r>e;){if(!await this.storage.delete("match_game",{parent_id:t.id,number:r}))throw Error("Could not adjust the match games when deleting.");r--}if(!await this.storage.update("match",t.id,{...t,child_count:e}))throw Error("Could not update the match.")}}e.Update=s},2038:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.InMemoryDatabase=void 0;const r=n(3188)();e.InMemoryDatabase=class{data={participant:[],stage:[],group:[],round:[],match:[],match_game:[]};setData(t){this.data=t}makeFilter(t){return e=>{let n=!0;for(const r of Object.keys(t))n=n&&e[r]===t[r];return n}}reset(){this.data={participant:[],stage:[],group:[],round:[],match:[],match_game:[]}}insert(t,e){let n=this.data[t].length>0?Math.max(...this.data[t].map((t=>t.id)))+1:0;if(!Array.isArray(e)){try{this.data[t].push({id:n,...e})}catch(t){return new Promise((t=>{t(-1)}))}return new Promise((t=>{t(n)}))}try{e.map((e=>{this.data[t].push({id:n++,...e})}))}catch(t){return new Promise((t=>{t(!1)}))}return new Promise((t=>{t(!0)}))}select(t,e){try{return new Promise(void 0===e?e=>{e(this.data[t].map(r))}:"number"==typeof e?n=>{n(r(this.data[t].find((t=>t.id===e))))}:n=>{n(this.data[t].filter(this.makeFilter(e)).map(r))})}catch(t){return new Promise((t=>{t(null)}))}}update(t,e,n){if("number"==typeof e)try{const r=this.getEntityIndexById(t,e);return this.setEntityByIndex(t,r,n),new Promise((t=>{t(!0)}))}catch(t){return new Promise((t=>{t(!1)}))}const r=this.data[t].filter(this.makeFilter(e));return r?(r.forEach((e=>{const r=this.getEntityIndexById(t,e.id),o=this.data[t][r];for(const t in n)o[t]&&"object"==typeof o[t]&&"object"==typeof n[t]?Object.assign(o[t],n[t]):o[t]=n[t];this.setEntityByIndex(t,r,o)})),new Promise((t=>{t(!0)}))):new Promise((t=>{t(!1)}))}delete(t,e){const n=this.data[t];if(!n)return new Promise((t=>{t(!1)}));if(!e)return this.data[t]=[],new Promise((t=>{t(!0)}));const r=this.makeFilter(e);return this.data[t]=n.filter((t=>!r(t))),new Promise((t=>{t(!0)}))}getEntityIndexById(t,e){const n=this.data[t].findIndex((t=>t.id===e));if(-1===n)throw new Error(`Entity in ${t} with id ${e} not found.`);return n}setEntityByIndex(t,e,n){this.data[t][e]=n}}},7021:function(t,e,n){"use strict";var r=this&&this.__createBinding||(Object.create?function(t,e,n,r){void 0===r&&(r=n);var o=Object.getOwnPropertyDescriptor(e,n);o&&!("get"in o?!e.__esModule:o.writable||o.configurable)||(o={enumerable:!0,get:function(){return e[n]}}),Object.defineProperty(t,r,o)}:function(t,e,n,r){void 0===r&&(r=n),t[r]=e[n]}),o=this&&this.__exportStar||function(t,e){for(var n in t)"default"===n||Object.prototype.hasOwnProperty.call(e,n)||r(e,t,n)};Object.defineProperty(e,"__esModule",{value:!0}),o(n(5118),e),o(n(7677),e),o(n(7121),e),o(n(2854),e)},7677:function(t,e){"use strict";Object.defineProperty(e,"__esModule",{value:!0})},2854:function(t,e){"use strict";var n;Object.defineProperty(e,"__esModule",{value:!0}),e.Status=void 0,(n=e.Status||(e.Status={}))[n.Locked=0]="Locked",n[n.Waiting=1]="Waiting",n[n.Ready=2]="Ready",n[n.Running=3]="Running",n[n.Completed=4]="Completed",n[n.Archived=5]="Archived"},7121:function(t,e){"use strict";Object.defineProperty(e,"__esModule",{value:!0})},5118:function(t,e){"use strict";Object.defineProperty(e,"__esModule",{value:!0})},13:function(t,e,n){"use strict";var r=n(6690),o=n(9728);function i(t){return t&&"object"==typeof t&&"default"in t?t:{default:t}}var a=i(r),s=i(o),u=[],c=u.forEach,l=u.slice,d=/^[\u0009\u0020-\u007e\u0080-\u00ff]+$/,p={name:"cookie",lookup:function(t){var e;if(t.lookupCookie&&"undefined"!=typeof document){var n=function(t){for(var e="".concat(t,"="),n=document.cookie.split(";"),r=0;r<n.length;r++){for(var o=n[r];" "===o.charAt(0);)o=o.substring(1,o.length);if(0===o.indexOf(e))return o.substring(e.length,o.length)}return null}(t.lookupCookie);n&&(e=n)}return e},cacheUserLanguage:function(t,e){e.lookupCookie&&"undefined"!=typeof document&&function(t,e,n,r){var o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:{path:"/",sameSite:"strict"};n&&(o.expires=new Date,o.expires.setTime(o.expires.getTime()+60*n*1e3)),r&&(o.domain=r),document.cookie=function(t,e,n){var r=n||{};r.path=r.path||"/";var o=encodeURIComponent(e),i="".concat(t,"=").concat(o);if(r.maxAge>0){var a=r.maxAge-0;if(Number.isNaN(a))throw new Error("maxAge should be a Number");i+="; Max-Age=".concat(Math.floor(a))}if(r.domain){if(!d.test(r.domain))throw new TypeError("option domain is invalid");i+="; Domain=".concat(r.domain)}if(r.path){if(!d.test(r.path))throw new TypeError("option path is invalid");i+="; Path=".concat(r.path)}if(r.expires){if("function"!=typeof r.expires.toUTCString)throw new TypeError("option expires is invalid");i+="; Expires=".concat(r.expires.toUTCString())}if(r.httpOnly&&(i+="; HttpOnly"),r.secure&&(i+="; Secure"),r.sameSite)switch("string"==typeof r.sameSite?r.sameSite.toLowerCase():r.sameSite){case!0:i+="; SameSite=Strict";break;case"lax":i+="; SameSite=Lax";break;case"strict":i+="; SameSite=Strict";break;case"none":i+="; SameSite=None";break;default:throw new TypeError("option sameSite is invalid")}return i}(t,encodeURIComponent(e),o)}(e.lookupCookie,t,e.cookieMinutes,e.cookieDomain,e.cookieOptions)}},f={name:"querystring",lookup:function(t){var e;if("undefined"!=typeof window){var n=window.location.search;!window.location.search&&window.location.hash&&window.location.hash.indexOf("?")>-1&&(n=window.location.hash.substring(window.location.hash.indexOf("?")));for(var r=n.substring(1).split("&"),o=0;o<r.length;o++){var i=r[o].indexOf("=");i>0&&r[o].substring(0,i)===t.lookupQuerystring&&(e=r[o].substring(i+1))}}return e}},h=null,g=function(){if(null!==h)return h;try{h="undefined"!==window&&null!==window.localStorage;var t="i18next.translate.boo";window.localStorage.setItem(t,"foo"),window.localStorage.removeItem(t)}catch(t){h=!1}return h},m={name:"localStorage",lookup:function(t){var e;if(t.lookupLocalStorage&&g()){var n=window.localStorage.getItem(t.lookupLocalStorage);n&&(e=n)}return e},cacheUserLanguage:function(t,e){e.lookupLocalStorage&&g()&&window.localStorage.setItem(e.lookupLocalStorage,t)}},v=null,b=function(){if(null!==v)return v;try{v="undefined"!==window&&null!==window.sessionStorage;var t="i18next.translate.boo";window.sessionStorage.setItem(t,"foo"),window.sessionStorage.removeItem(t)}catch(t){v=!1}return v},y={name:"sessionStorage",lookup:function(t){var e;if(t.lookupSessionStorage&&b()){var n=window.sessionStorage.getItem(t.lookupSessionStorage);n&&(e=n)}return e},cacheUserLanguage:function(t,e){e.lookupSessionStorage&&b()&&window.sessionStorage.setItem(e.lookupSessionStorage,t)}},w={name:"navigator",lookup:function(t){var e=[];if("undefined"!=typeof navigator){if(navigator.languages)for(var n=0;n<navigator.languages.length;n++)e.push(navigator.languages[n]);navigator.userLanguage&&e.push(navigator.userLanguage),navigator.language&&e.push(navigator.language)}return e.length>0?e:void 0}},k={name:"htmlTag",lookup:function(t){var e,n=t.htmlTag||("undefined"!=typeof document?document.documentElement:null);return n&&"function"==typeof n.getAttribute&&(e=n.getAttribute("lang")),e}},S={name:"path",lookup:function(t){var e;if("undefined"!=typeof window){var n=window.location.pathname.match(/\/([a-zA-Z-]*)/g);if(n instanceof Array)if("number"==typeof t.lookupFromPathIndex){if("string"!=typeof n[t.lookupFromPathIndex])return;e=n[t.lookupFromPathIndex].replace("/","")}else e=n[0].replace("/","")}return e}},M={name:"subdomain",lookup:function(t){var e="number"==typeof t.lookupFromSubdomainIndex?t.lookupFromSubdomainIndex+1:1,n="undefined"!=typeof window&&window.location&&window.location.hostname&&window.location.hostname.match(/^(\w{2,5})\.(([a-z0-9-]{1,63}\.[a-z]{2,6})|localhost)/i);if(n)return n[e]}},O=function(){function t(e){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};a.default(this,t),this.type="languageDetector",this.detectors={},this.init(e,n)}return s.default(t,[{key:"init",value:function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};this.services=t,this.options=function(t){return c.call(l.call(arguments,1),(function(e){if(e)for(var n in e)void 0===t[n]&&(t[n]=e[n])})),t}(e,this.options||{},{order:["querystring","cookie","localStorage","sessionStorage","navigator","htmlTag"],lookupQuerystring:"lng",lookupCookie:"i18next",lookupLocalStorage:"i18nextLng",lookupSessionStorage:"i18nextLng",caches:["localStorage"],excludeCacheFor:["cimode"]}),this.options.lookupFromUrlIndex&&(this.options.lookupFromPathIndex=this.options.lookupFromUrlIndex),this.i18nOptions=n,this.addDetector(p),this.addDetector(f),this.addDetector(m),this.addDetector(y),this.addDetector(w),this.addDetector(k),this.addDetector(S),this.addDetector(M)}},{key:"addDetector",value:function(t){this.detectors[t.name]=t}},{key:"detect",value:function(t){var e=this;t||(t=this.options.order);var n=[];return t.forEach((function(t){if(e.detectors[t]){var r=e.detectors[t].lookup(e.options);r&&"string"==typeof r&&(r=[r]),r&&(n=n.concat(r))}})),this.services.languageUtils.getBestMatchFromCodes?n:n.length>0?n[0]:null}},{key:"cacheUserLanguage",value:function(t,e){var n=this;e||(e=this.options.caches),e&&(this.options.excludeCacheFor&&this.options.excludeCacheFor.indexOf(t)>-1||e.forEach((function(e){n.detectors[e]&&n.detectors[e].cacheUserLanguage(t,n.options)})))}}]),t}();O.type="languageDetector",t.exports=O},6073:function(t,e,n){"use strict";var r=n(8698),o=n(6690),i=n(9728),a=n(6115),s=n(1655),u=n(4993),c=n(3808),l=n(8416),d=n(1589);function p(t){return t&&"object"==typeof t&&"default"in t?t:{default:t}}var f=p(r),h=p(o),g=p(i),m=p(a),v=p(s),b=p(u),y=p(c),w=p(l),k=p(d);function S(t,e){var n=Object.keys(t);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(t);e&&(r=r.filter((function(e){return Object.getOwnPropertyDescriptor(t,e).enumerable}))),n.push.apply(n,r)}return n}function M(t){for(var e=1;e<arguments.length;e++){var n=null!=arguments[e]?arguments[e]:{};e%2?S(Object(n),!0).forEach((function(e){w.default(t,e,n[e])})):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(n)):S(Object(n)).forEach((function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(n,e))}))}return t}var O={type:"logger",log:function(t){this.output("log",t)},warn:function(t){this.output("warn",t)},error:function(t){this.output("error",t)},output:function(t,e){console&&console[t]&&console[t].apply(console,e)}},_=function(){function t(e){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};h.default(this,t),this.init(e,n)}return g.default(t,[{key:"init",value:function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};this.prefix=e.prefix||"i18next:",this.logger=t||O,this.options=e,this.debug=e.debug}},{key:"setDebug",value:function(t){this.debug=t}},{key:"log",value:function(){for(var t=arguments.length,e=new Array(t),n=0;n<t;n++)e[n]=arguments[n];return this.forward(e,"log","",!0)}},{key:"warn",value:function(){for(var t=arguments.length,e=new Array(t),n=0;n<t;n++)e[n]=arguments[n];return this.forward(e,"warn","",!0)}},{key:"error",value:function(){for(var t=arguments.length,e=new Array(t),n=0;n<t;n++)e[n]=arguments[n];return this.forward(e,"error","")}},{key:"deprecate",value:function(){for(var t=arguments.length,e=new Array(t),n=0;n<t;n++)e[n]=arguments[n];return this.forward(e,"warn","WARNING DEPRECATED: ",!0)}},{key:"forward",value:function(t,e,n,r){return r&&!this.debug?null:("string"==typeof t[0]&&(t[0]="".concat(n).concat(this.prefix," ").concat(t[0])),this.logger[e](t))}},{key:"create",value:function(e){return new t(this.logger,M(M({},{prefix:"".concat(this.prefix,":").concat(e,":")}),this.options))}},{key:"clone",value:function(e){return(e=e||this.options).prefix=e.prefix||this.prefix,new t(this.logger,e)}}]),t}(),E=new _,x=function(){function t(){h.default(this,t),this.observers={}}return g.default(t,[{key:"on",value:function(t,e){var n=this;return t.split(" ").forEach((function(t){n.observers[t]=n.observers[t]||[],n.observers[t].push(e)})),this}},{key:"off",value:function(t,e){this.observers[t]&&(e?this.observers[t]=this.observers[t].filter((function(t){return t!==e})):delete this.observers[t])}},{key:"emit",value:function(t){for(var e=arguments.length,n=new Array(e>1?e-1:0),r=1;r<e;r++)n[r-1]=arguments[r];this.observers[t]&&[].concat(this.observers[t]).forEach((function(t){t.apply(void 0,n)})),this.observers["*"]&&[].concat(this.observers["*"]).forEach((function(e){e.apply(e,[t].concat(n))}))}}]),t}();function R(){var t,e,n=new Promise((function(n,r){t=n,e=r}));return n.resolve=t,n.reject=e,n}function P(t){return null==t?"":""+t}function C(t,e,n){function r(t){return t&&t.indexOf("###")>-1?t.replace(/###/g,"."):t}function o(){return!t||"string"==typeof t}for(var i="string"!=typeof e?[].concat(e):e.split(".");i.length>1;){if(o())return{};var a=r(i.shift());!t[a]&&n&&(t[a]=new n),t=Object.prototype.hasOwnProperty.call(t,a)?t[a]:{}}return o()?{}:{obj:t,k:r(i.shift())}}function L(t,e,n){var r=C(t,e,Object);r.obj[r.k]=n}function N(t,e){var n=C(t,e),r=n.obj,o=n.k;if(r)return r[o]}function j(t,e,n){var r=N(t,n);return void 0!==r?r:N(e,n)}function F(t,e,n){for(var r in e)"__proto__"!==r&&"constructor"!==r&&(r in t?"string"==typeof t[r]||t[r]instanceof String||"string"==typeof e[r]||e[r]instanceof String?n&&(t[r]=e[r]):F(t[r],e[r],n):t[r]=e[r]);return t}function B(t){return t.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g,"\\$&")}var D={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;","/":"&#x2F;"};function I(t){return"string"==typeof t?t.replace(/[&<>"'\/]/g,(function(t){return D[t]})):t}var T="undefined"!=typeof window&&window.navigator&&void 0===window.navigator.userAgentData&&window.navigator.userAgent&&window.navigator.userAgent.indexOf("MSIE")>-1,A=[" ",",","?","!",";"];function U(t,e){var n=Object.keys(t);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(t);e&&(r=r.filter((function(e){return Object.getOwnPropertyDescriptor(t,e).enumerable}))),n.push.apply(n,r)}return n}function G(t){for(var e=1;e<arguments.length;e++){var n=null!=arguments[e]?arguments[e]:{};e%2?U(Object(n),!0).forEach((function(e){w.default(t,e,n[e])})):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(n)):U(Object(n)).forEach((function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(n,e))}))}return t}function $(t,e){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:".";if(t){if(t[e])return t[e];for(var r=e.split(n),o=t,i=0;i<r.length;++i){if(!o)return;if("string"==typeof o[r[i]]&&i+1<r.length)return;if(void 0===o[r[i]]){for(var a=2,s=r.slice(i,i+a).join(n),u=o[s];void 0===u&&r.length>i+a;)a++,u=o[s=r.slice(i,i+a).join(n)];if(void 0===u)return;if(null===u)return null;if(e.endsWith(s)){if("string"==typeof u)return u;if(s&&"string"==typeof u[s])return u[s]}var c=r.slice(i+a).join(n);return c?$(u,c,n):void 0}o=o[r[i]]}return o}}var W=function(t){v.default(o,t);var e,n,r=(e=o,n=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}(),function(){var t,r=y.default(e);if(n){var o=y.default(this).constructor;t=Reflect.construct(r,arguments,o)}else t=r.apply(this,arguments);return b.default(this,t)});function o(t){var e,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{ns:["translation"],defaultNS:"translation"};return h.default(this,o),e=r.call(this),T&&x.call(m.default(e)),e.data=t||{},e.options=n,void 0===e.options.keySeparator&&(e.options.keySeparator="."),void 0===e.options.ignoreJSONStructure&&(e.options.ignoreJSONStructure=!0),e}return g.default(o,[{key:"addNamespaces",value:function(t){this.options.ns.indexOf(t)<0&&this.options.ns.push(t)}},{key:"removeNamespaces",value:function(t){var e=this.options.ns.indexOf(t);e>-1&&this.options.ns.splice(e,1)}},{key:"getResource",value:function(t,e,n){var r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{},o=void 0!==r.keySeparator?r.keySeparator:this.options.keySeparator,i=void 0!==r.ignoreJSONStructure?r.ignoreJSONStructure:this.options.ignoreJSONStructure,a=[t,e];n&&"string"!=typeof n&&(a=a.concat(n)),n&&"string"==typeof n&&(a=a.concat(o?n.split(o):n)),t.indexOf(".")>-1&&(a=t.split("."));var s=N(this.data,a);return s||!i||"string"!=typeof n?s:$(this.data&&this.data[t]&&this.data[t][e],n,o)}},{key:"addResource",value:function(t,e,n,r){var o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:{silent:!1},i=this.options.keySeparator;void 0===i&&(i=".");var a=[t,e];n&&(a=a.concat(i?n.split(i):n)),t.indexOf(".")>-1&&(r=e,e=(a=t.split("."))[1]),this.addNamespaces(e),L(this.data,a,r),o.silent||this.emit("added",t,e,n,r)}},{key:"addResources",value:function(t,e,n){var r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{silent:!1};for(var o in n)"string"!=typeof n[o]&&"[object Array]"!==Object.prototype.toString.apply(n[o])||this.addResource(t,e,o,n[o],{silent:!0});r.silent||this.emit("added",t,e,n)}},{key:"addResourceBundle",value:function(t,e,n,r,o){var i=arguments.length>5&&void 0!==arguments[5]?arguments[5]:{silent:!1},a=[t,e];t.indexOf(".")>-1&&(r=n,n=e,e=(a=t.split("."))[1]),this.addNamespaces(e);var s=N(this.data,a)||{};r?F(s,n,o):s=G(G({},s),n),L(this.data,a,s),i.silent||this.emit("added",t,e,n)}},{key:"removeResourceBundle",value:function(t,e){this.hasResourceBundle(t,e)&&delete this.data[t][e],this.removeNamespaces(e),this.emit("removed",t,e)}},{key:"hasResourceBundle",value:function(t,e){return void 0!==this.getResource(t,e)}},{key:"getResourceBundle",value:function(t,e){return e||(e=this.options.defaultNS),"v1"===this.options.compatibilityAPI?G(G({},{}),this.getResource(t,e)):this.getResource(t,e)}},{key:"getDataByLanguage",value:function(t){return this.data[t]}},{key:"hasLanguageSomeTranslations",value:function(t){var e=this.getDataByLanguage(t);return!!(e&&Object.keys(e)||[]).find((function(t){return e[t]&&Object.keys(e[t]).length>0}))}},{key:"toJSON",value:function(){return this.data}}]),o}(x),z={processors:{},addPostProcessor:function(t){this.processors[t.name]=t},handle:function(t,e,n,r,o){var i=this;return t.forEach((function(t){i.processors[t]&&(e=i.processors[t].process(e,n,r,o))})),e}};function H(t,e){var n=Object.keys(t);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(t);e&&(r=r.filter((function(e){return Object.getOwnPropertyDescriptor(t,e).enumerable}))),n.push.apply(n,r)}return n}function V(t){for(var e=1;e<arguments.length;e++){var n=null!=arguments[e]?arguments[e]:{};e%2?H(Object(n),!0).forEach((function(e){w.default(t,e,n[e])})):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(n)):H(Object(n)).forEach((function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(n,e))}))}return t}var q={},K=function(t){v.default(o,t);var e,n,r=(e=o,n=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}(),function(){var t,r=y.default(e);if(n){var o=y.default(this).constructor;t=Reflect.construct(r,arguments,o)}else t=r.apply(this,arguments);return b.default(this,t)});function o(t){var e,n,i,a,s=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return h.default(this,o),e=r.call(this),T&&x.call(m.default(e)),n=["resourceStore","languageUtils","pluralResolver","interpolator","backendConnector","i18nFormat","utils"],i=t,a=m.default(e),n.forEach((function(t){i[t]&&(a[t]=i[t])})),e.options=s,void 0===e.options.keySeparator&&(e.options.keySeparator="."),e.logger=E.create("translator"),e}return g.default(o,[{key:"changeLanguage",value:function(t){t&&(this.language=t)}},{key:"exists",value:function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{interpolation:{}};if(null==t)return!1;var n=this.resolve(t,e);return n&&void 0!==n.res}},{key:"extractFromKey",value:function(t,e){var n=void 0!==e.nsSeparator?e.nsSeparator:this.options.nsSeparator;void 0===n&&(n=":");var r=void 0!==e.keySeparator?e.keySeparator:this.options.keySeparator,o=e.ns||this.options.defaultNS||[],i=n&&t.indexOf(n)>-1,a=!(this.options.userDefinedKeySeparator||e.keySeparator||this.options.userDefinedNsSeparator||e.nsSeparator||function(t,e,n){e=e||"",n=n||"";var r=A.filter((function(t){return e.indexOf(t)<0&&n.indexOf(t)<0}));if(0===r.length)return!0;var o=new RegExp("(".concat(r.map((function(t){return"?"===t?"\\?":t})).join("|"),")")),i=!o.test(t);if(!i){var a=t.indexOf(n);a>0&&!o.test(t.substring(0,a))&&(i=!0)}return i}(t,n,r));if(i&&!a){var s=t.match(this.interpolator.nestingRegexp);if(s&&s.length>0)return{key:t,namespaces:o};var u=t.split(n);(n!==r||n===r&&this.options.ns.indexOf(u[0])>-1)&&(o=u.shift()),t=u.join(r)}return"string"==typeof o&&(o=[o]),{key:t,namespaces:o}}},{key:"translate",value:function(t,e,n){var r=this;if("object"!==f.default(e)&&this.options.overloadTranslationOptionHandler&&(e=this.options.overloadTranslationOptionHandler(arguments)),e||(e={}),null==t)return"";Array.isArray(t)||(t=[String(t)]);var i=void 0!==e.returnDetails?e.returnDetails:this.options.returnDetails,a=void 0!==e.keySeparator?e.keySeparator:this.options.keySeparator,s=this.extractFromKey(t[t.length-1],e),u=s.key,c=s.namespaces,l=c[c.length-1],d=e.lng||this.language,p=e.appendNamespaceToCIMode||this.options.appendNamespaceToCIMode;if(d&&"cimode"===d.toLowerCase()){if(p){var h=e.nsSeparator||this.options.nsSeparator;return i?(g.res="".concat(l).concat(h).concat(u),g):"".concat(l).concat(h).concat(u)}return i?(g.res=u,g):u}var g=this.resolve(t,e),m=g&&g.res,v=g&&g.usedKey||u,b=g&&g.exactUsedKey||u,y=Object.prototype.toString.apply(m),w=void 0!==e.joinArrays?e.joinArrays:this.options.joinArrays,k=!this.i18nFormat||this.i18nFormat.handleAsObject;if(k&&m&&"string"!=typeof m&&"boolean"!=typeof m&&"number"!=typeof m&&["[object Number]","[object Function]","[object RegExp]"].indexOf(y)<0&&("string"!=typeof w||"[object Array]"!==y)){if(!e.returnObjects&&!this.options.returnObjects){this.options.returnedObjectHandler||this.logger.warn("accessing an object - but returnObjects options is not enabled!");var S=this.options.returnedObjectHandler?this.options.returnedObjectHandler(v,m,V(V({},e),{},{ns:c})):"key '".concat(u," (").concat(this.language,")' returned an object instead of string.");return i?(g.res=S,g):S}if(a){var M="[object Array]"===y,O=M?[]:{},_=M?b:v;for(var E in m)if(Object.prototype.hasOwnProperty.call(m,E)){var x="".concat(_).concat(a).concat(E);O[E]=this.translate(x,V(V({},e),{joinArrays:!1,ns:c})),O[E]===x&&(O[E]=m[E])}m=O}}else if(k&&"string"==typeof w&&"[object Array]"===y)(m=m.join(w))&&(m=this.extendTranslation(m,t,e,n));else{var R=!1,P=!1,C=void 0!==e.count&&"string"!=typeof e.count,L=o.hasDefaultValue(e),N=C?this.pluralResolver.getSuffix(d,e.count,e):"",j=e["defaultValue".concat(N)]||e.defaultValue;!this.isValidLookup(m)&&L&&(R=!0,m=j),this.isValidLookup(m)||(P=!0,m=u);var F=(e.missingKeyNoValueFallbackToKey||this.options.missingKeyNoValueFallbackToKey)&&P?void 0:m,B=L&&j!==m&&this.options.updateMissing;if(P||R||B){if(this.logger.log(B?"updateKey":"missingKey",d,l,u,B?j:m),a){var D=this.resolve(u,V(V({},e),{},{keySeparator:!1}));D&&D.res&&this.logger.warn("Seems the loaded translations were in flat JSON format instead of nested. Either set keySeparator: false on init or make sure your translations are published in nested format.")}var I=[],T=this.languageUtils.getFallbackCodes(this.options.fallbackLng,e.lng||this.language);if("fallback"===this.options.saveMissingTo&&T&&T[0])for(var A=0;A<T.length;A++)I.push(T[A]);else"all"===this.options.saveMissingTo?I=this.languageUtils.toResolveHierarchy(e.lng||this.language):I.push(e.lng||this.language);var U=function(t,n,o){var i=L&&o!==m?o:F;r.options.missingKeyHandler?r.options.missingKeyHandler(t,l,n,i,B,e):r.backendConnector&&r.backendConnector.saveMissing&&r.backendConnector.saveMissing(t,l,n,i,B,e),r.emit("missingKey",t,l,n,m)};this.options.saveMissing&&(this.options.saveMissingPlurals&&C?I.forEach((function(t){r.pluralResolver.getSuffixes(t,e).forEach((function(n){U([t],u+n,e["defaultValue".concat(n)]||j)}))})):U(I,u,j))}m=this.extendTranslation(m,t,e,g,n),P&&m===u&&this.options.appendNamespaceToMissingKey&&(m="".concat(l,":").concat(u)),(P||R)&&this.options.parseMissingKeyHandler&&(m="v1"!==this.options.compatibilityAPI?this.options.parseMissingKeyHandler(this.options.appendNamespaceToMissingKey?"".concat(l,":").concat(u):u,R?m:void 0):this.options.parseMissingKeyHandler(m))}return i?(g.res=m,g):m}},{key:"extendTranslation",value:function(t,e,n,r,o){var i=this;if(this.i18nFormat&&this.i18nFormat.parse)t=this.i18nFormat.parse(t,V(V({},this.options.interpolation.defaultVariables),n),r.usedLng,r.usedNS,r.usedKey,{resolved:r});else if(!n.skipInterpolation){n.interpolation&&this.interpolator.init(V(V({},n),{interpolation:V(V({},this.options.interpolation),n.interpolation)}));var a,s="string"==typeof t&&(n&&n.interpolation&&void 0!==n.interpolation.skipOnVariables?n.interpolation.skipOnVariables:this.options.interpolation.skipOnVariables);if(s){var u=t.match(this.interpolator.nestingRegexp);a=u&&u.length}var c=n.replace&&"string"!=typeof n.replace?n.replace:n;if(this.options.interpolation.defaultVariables&&(c=V(V({},this.options.interpolation.defaultVariables),c)),t=this.interpolator.interpolate(t,c,n.lng||this.language,n),s){var l=t.match(this.interpolator.nestingRegexp);a<(l&&l.length)&&(n.nest=!1)}!1!==n.nest&&(t=this.interpolator.nest(t,(function(){for(var t=arguments.length,r=new Array(t),a=0;a<t;a++)r[a]=arguments[a];return o&&o[0]===r[0]&&!n.context?(i.logger.warn("It seems you are nesting recursively key: ".concat(r[0]," in key: ").concat(e[0])),null):i.translate.apply(i,r.concat([e]))}),n)),n.interpolation&&this.interpolator.reset()}var d=n.postProcess||this.options.postProcess,p="string"==typeof d?[d]:d;return null!=t&&p&&p.length&&!1!==n.applyPostProcessor&&(t=z.handle(p,t,e,this.options&&this.options.postProcessPassResolved?V({i18nResolved:r},n):n,this)),t}},{key:"resolve",value:function(t){var e,n,r,o,i,a=this,s=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return"string"==typeof t&&(t=[t]),t.forEach((function(t){if(!a.isValidLookup(e)){var u=a.extractFromKey(t,s),c=u.key;n=c;var l=u.namespaces;a.options.fallbackNS&&(l=l.concat(a.options.fallbackNS));var d=void 0!==s.count&&"string"!=typeof s.count,p=d&&!s.ordinal&&0===s.count&&a.pluralResolver.shouldUseIntlApi(),f=void 0!==s.context&&("string"==typeof s.context||"number"==typeof s.context)&&""!==s.context,h=s.lngs?s.lngs:a.languageUtils.toResolveHierarchy(s.lng||a.language,s.fallbackLng);l.forEach((function(t){a.isValidLookup(e)||(i=t,!q["".concat(h[0],"-").concat(t)]&&a.utils&&a.utils.hasLoadedNamespace&&!a.utils.hasLoadedNamespace(i)&&(q["".concat(h[0],"-").concat(t)]=!0,a.logger.warn('key "'.concat(n,'" for languages "').concat(h.join(", "),'" won\'t get resolved as namespace "').concat(i,'" was not yet loaded'),"This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!")),h.forEach((function(n){if(!a.isValidLookup(e)){o=n;var i,u=[c];if(a.i18nFormat&&a.i18nFormat.addLookupKeys)a.i18nFormat.addLookupKeys(u,c,n,t,s);else{var l;d&&(l=a.pluralResolver.getSuffix(n,s.count,s));var h="".concat(a.options.pluralSeparator,"zero");if(d&&(u.push(c+l),p&&u.push(c+h)),f){var g="".concat(c).concat(a.options.contextSeparator).concat(s.context);u.push(g),d&&(u.push(g+l),p&&u.push(g+h))}}for(;i=u.pop();)a.isValidLookup(e)||(r=i,e=a.getResource(n,t,i,s))}})))}))}})),{res:e,usedKey:n,exactUsedKey:r,usedLng:o,usedNS:i}}},{key:"isValidLookup",value:function(t){return!(void 0===t||!this.options.returnNull&&null===t||!this.options.returnEmptyString&&""===t)}},{key:"getResource",value:function(t,e,n){var r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return this.i18nFormat&&this.i18nFormat.getResource?this.i18nFormat.getResource(t,e,n,r):this.resourceStore.getResource(t,e,n,r)}}],[{key:"hasDefaultValue",value:function(t){var e="defaultValue";for(var n in t)if(Object.prototype.hasOwnProperty.call(t,n)&&e===n.substring(0,e.length)&&void 0!==t[n])return!0;return!1}}]),o}(x);function J(t){return t.charAt(0).toUpperCase()+t.slice(1)}var Y=function(){function t(e){h.default(this,t),this.options=e,this.supportedLngs=this.options.supportedLngs||!1,this.logger=E.create("languageUtils")}return g.default(t,[{key:"getScriptPartFromCode",value:function(t){if(!t||t.indexOf("-")<0)return null;var e=t.split("-");return 2===e.length?null:(e.pop(),"x"===e[e.length-1].toLowerCase()?null:this.formatLanguageCode(e.join("-")))}},{key:"getLanguagePartFromCode",value:function(t){if(!t||t.indexOf("-")<0)return t;var e=t.split("-");return this.formatLanguageCode(e[0])}},{key:"formatLanguageCode",value:function(t){if("string"==typeof t&&t.indexOf("-")>-1){var e=["hans","hant","latn","cyrl","cans","mong","arab"],n=t.split("-");return this.options.lowerCaseLng?n=n.map((function(t){return t.toLowerCase()})):2===n.length?(n[0]=n[0].toLowerCase(),n[1]=n[1].toUpperCase(),e.indexOf(n[1].toLowerCase())>-1&&(n[1]=J(n[1].toLowerCase()))):3===n.length&&(n[0]=n[0].toLowerCase(),2===n[1].length&&(n[1]=n[1].toUpperCase()),"sgn"!==n[0]&&2===n[2].length&&(n[2]=n[2].toUpperCase()),e.indexOf(n[1].toLowerCase())>-1&&(n[1]=J(n[1].toLowerCase())),e.indexOf(n[2].toLowerCase())>-1&&(n[2]=J(n[2].toLowerCase()))),n.join("-")}return this.options.cleanCode||this.options.lowerCaseLng?t.toLowerCase():t}},{key:"isSupportedCode",value:function(t){return("languageOnly"===this.options.load||this.options.nonExplicitSupportedLngs)&&(t=this.getLanguagePartFromCode(t)),!this.supportedLngs||!this.supportedLngs.length||this.supportedLngs.indexOf(t)>-1}},{key:"getBestMatchFromCodes",value:function(t){var e,n=this;return t?(t.forEach((function(t){if(!e){var r=n.formatLanguageCode(t);n.options.supportedLngs&&!n.isSupportedCode(r)||(e=r)}})),!e&&this.options.supportedLngs&&t.forEach((function(t){if(!e){var r=n.getLanguagePartFromCode(t);if(n.isSupportedCode(r))return e=r;e=n.options.supportedLngs.find((function(t){if(0===t.indexOf(r))return t}))}})),e||(e=this.getFallbackCodes(this.options.fallbackLng)[0]),e):null}},{key:"getFallbackCodes",value:function(t,e){if(!t)return[];if("function"==typeof t&&(t=t(e)),"string"==typeof t&&(t=[t]),"[object Array]"===Object.prototype.toString.apply(t))return t;if(!e)return t.default||[];var n=t[e];return n||(n=t[this.getScriptPartFromCode(e)]),n||(n=t[this.formatLanguageCode(e)]),n||(n=t[this.getLanguagePartFromCode(e)]),n||(n=t.default),n||[]}},{key:"toResolveHierarchy",value:function(t,e){var n=this,r=this.getFallbackCodes(e||this.options.fallbackLng||[],t),o=[],i=function(t){t&&(n.isSupportedCode(t)?o.push(t):n.logger.warn("rejecting language code not found in supportedLngs: ".concat(t)))};return"string"==typeof t&&t.indexOf("-")>-1?("languageOnly"!==this.options.load&&i(this.formatLanguageCode(t)),"languageOnly"!==this.options.load&&"currentOnly"!==this.options.load&&i(this.getScriptPartFromCode(t)),"currentOnly"!==this.options.load&&i(this.getLanguagePartFromCode(t))):"string"==typeof t&&i(this.formatLanguageCode(t)),r.forEach((function(t){o.indexOf(t)<0&&i(n.formatLanguageCode(t))})),o}}]),t}(),Q=[{lngs:["ach","ak","am","arn","br","fil","gun","ln","mfe","mg","mi","oc","pt","pt-BR","tg","tl","ti","tr","uz","wa"],nr:[1,2],fc:1},{lngs:["af","an","ast","az","bg","bn","ca","da","de","dev","el","en","eo","es","et","eu","fi","fo","fur","fy","gl","gu","ha","hi","hu","hy","ia","it","kk","kn","ku","lb","mai","ml","mn","mr","nah","nap","nb","ne","nl","nn","no","nso","pa","pap","pms","ps","pt-PT","rm","sco","se","si","so","son","sq","sv","sw","ta","te","tk","ur","yo"],nr:[1,2],fc:2},{lngs:["ay","bo","cgg","fa","ht","id","ja","jbo","ka","km","ko","ky","lo","ms","sah","su","th","tt","ug","vi","wo","zh"],nr:[1],fc:3},{lngs:["be","bs","cnr","dz","hr","ru","sr","uk"],nr:[1,2,5],fc:4},{lngs:["ar"],nr:[0,1,2,3,11,100],fc:5},{lngs:["cs","sk"],nr:[1,2,5],fc:6},{lngs:["csb","pl"],nr:[1,2,5],fc:7},{lngs:["cy"],nr:[1,2,3,8],fc:8},{lngs:["fr"],nr:[1,2],fc:9},{lngs:["ga"],nr:[1,2,3,7,11],fc:10},{lngs:["gd"],nr:[1,2,3,20],fc:11},{lngs:["is"],nr:[1,2],fc:12},{lngs:["jv"],nr:[0,1],fc:13},{lngs:["kw"],nr:[1,2,3,4],fc:14},{lngs:["lt"],nr:[1,2,10],fc:15},{lngs:["lv"],nr:[1,2,0],fc:16},{lngs:["mk"],nr:[1,2],fc:17},{lngs:["mnk"],nr:[0,1,2],fc:18},{lngs:["mt"],nr:[1,2,11,20],fc:19},{lngs:["or"],nr:[2,1],fc:2},{lngs:["ro"],nr:[1,2,20],fc:20},{lngs:["sl"],nr:[5,1,2,3],fc:21},{lngs:["he","iw"],nr:[1,2,20,21],fc:22}],X={1:function(t){return Number(t>1)},2:function(t){return Number(1!=t)},3:function(t){return 0},4:function(t){return Number(t%10==1&&t%100!=11?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2)},5:function(t){return Number(0==t?0:1==t?1:2==t?2:t%100>=3&&t%100<=10?3:t%100>=11?4:5)},6:function(t){return Number(1==t?0:t>=2&&t<=4?1:2)},7:function(t){return Number(1==t?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2)},8:function(t){return Number(1==t?0:2==t?1:8!=t&&11!=t?2:3)},9:function(t){return Number(t>=2)},10:function(t){return Number(1==t?0:2==t?1:t<7?2:t<11?3:4)},11:function(t){return Number(1==t||11==t?0:2==t||12==t?1:t>2&&t<20?2:3)},12:function(t){return Number(t%10!=1||t%100==11)},13:function(t){return Number(0!==t)},14:function(t){return Number(1==t?0:2==t?1:3==t?2:3)},15:function(t){return Number(t%10==1&&t%100!=11?0:t%10>=2&&(t%100<10||t%100>=20)?1:2)},16:function(t){return Number(t%10==1&&t%100!=11?0:0!==t?1:2)},17:function(t){return Number(1==t||t%10==1&&t%100!=11?0:1)},18:function(t){return Number(0==t?0:1==t?1:2)},19:function(t){return Number(1==t?0:0==t||t%100>1&&t%100<11?1:t%100>10&&t%100<20?2:3)},20:function(t){return Number(1==t?0:0==t||t%100>0&&t%100<20?1:2)},21:function(t){return Number(t%100==1?1:t%100==2?2:t%100==3||t%100==4?3:0)},22:function(t){return Number(1==t?0:2==t?1:(t<0||t>10)&&t%10==0?2:3)}},Z=["v1","v2","v3"],tt={zero:0,one:1,two:2,few:3,many:4,other:5},et=function(){function t(e){var n,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};h.default(this,t),this.languageUtils=e,this.options=r,this.logger=E.create("pluralResolver"),this.options.compatibilityJSON&&"v4"!==this.options.compatibilityJSON||"undefined"!=typeof Intl&&Intl.PluralRules||(this.options.compatibilityJSON="v3",this.logger.error("Your environment seems not to be Intl API compatible, use an Intl.PluralRules polyfill. Will fallback to the compatibilityJSON v3 format handling.")),this.rules=(n={},Q.forEach((function(t){t.lngs.forEach((function(e){n[e]={numbers:t.nr,plurals:X[t.fc]}}))})),n)}return g.default(t,[{key:"addRule",value:function(t,e){this.rules[t]=e}},{key:"getRule",value:function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(this.shouldUseIntlApi())try{return new Intl.PluralRules(t,{type:e.ordinal?"ordinal":"cardinal"})}catch(t){return}return this.rules[t]||this.rules[this.languageUtils.getLanguagePartFromCode(t)]}},{key:"needsPlural",value:function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},n=this.getRule(t,e);return this.shouldUseIntlApi()?n&&n.resolvedOptions().pluralCategories.length>1:n&&n.numbers.length>1}},{key:"getPluralFormsOfKey",value:function(t,e){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};return this.getSuffixes(t,n).map((function(t){return"".concat(e).concat(t)}))}},{key:"getSuffixes",value:function(t){var e=this,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},r=this.getRule(t,n);return r?this.shouldUseIntlApi()?r.resolvedOptions().pluralCategories.sort((function(t,e){return tt[t]-tt[e]})).map((function(t){return"".concat(e.options.prepend).concat(t)})):r.numbers.map((function(r){return e.getSuffix(t,r,n)})):[]}},{key:"getSuffix",value:function(t,e){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},r=this.getRule(t,n);return r?this.shouldUseIntlApi()?"".concat(this.options.prepend).concat(r.select(e)):this.getSuffixRetroCompatible(r,e):(this.logger.warn("no plural rule found for: ".concat(t)),"")}},{key:"getSuffixRetroCompatible",value:function(t,e){var n=this,r=t.noAbs?t.plurals(e):t.plurals(Math.abs(e)),o=t.numbers[r];this.options.simplifyPluralSuffix&&2===t.numbers.length&&1===t.numbers[0]&&(2===o?o="plural":1===o&&(o=""));var i=function(){return n.options.prepend&&o.toString()?n.options.prepend+o.toString():o.toString()};return"v1"===this.options.compatibilityJSON?1===o?"":"number"==typeof o?"_plural_".concat(o.toString()):i():"v2"===this.options.compatibilityJSON||this.options.simplifyPluralSuffix&&2===t.numbers.length&&1===t.numbers[0]?i():this.options.prepend&&r.toString()?this.options.prepend+r.toString():r.toString()}},{key:"shouldUseIntlApi",value:function(){return!Z.includes(this.options.compatibilityJSON)}}]),t}();function nt(t,e){var n=Object.keys(t);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(t);e&&(r=r.filter((function(e){return Object.getOwnPropertyDescriptor(t,e).enumerable}))),n.push.apply(n,r)}return n}function rt(t){for(var e=1;e<arguments.length;e++){var n=null!=arguments[e]?arguments[e]:{};e%2?nt(Object(n),!0).forEach((function(e){w.default(t,e,n[e])})):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(n)):nt(Object(n)).forEach((function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(n,e))}))}return t}var ot=function(){function t(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};h.default(this,t),this.logger=E.create("interpolator"),this.options=e,this.format=e.interpolation&&e.interpolation.format||function(t){return t},this.init(e)}return g.default(t,[{key:"init",value:function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};t.interpolation||(t.interpolation={escapeValue:!0});var e=t.interpolation;this.escape=void 0!==e.escape?e.escape:I,this.escapeValue=void 0===e.escapeValue||e.escapeValue,this.useRawValueToEscape=void 0!==e.useRawValueToEscape&&e.useRawValueToEscape,this.prefix=e.prefix?B(e.prefix):e.prefixEscaped||"{{",this.suffix=e.suffix?B(e.suffix):e.suffixEscaped||"}}",this.formatSeparator=e.formatSeparator?e.formatSeparator:e.formatSeparator||",",this.unescapePrefix=e.unescapeSuffix?"":e.unescapePrefix||"-",this.unescapeSuffix=this.unescapePrefix?"":e.unescapeSuffix||"",this.nestingPrefix=e.nestingPrefix?B(e.nestingPrefix):e.nestingPrefixEscaped||B("$t("),this.nestingSuffix=e.nestingSuffix?B(e.nestingSuffix):e.nestingSuffixEscaped||B(")"),this.nestingOptionsSeparator=e.nestingOptionsSeparator?e.nestingOptionsSeparator:e.nestingOptionsSeparator||",",this.maxReplaces=e.maxReplaces?e.maxReplaces:1e3,this.alwaysFormat=void 0!==e.alwaysFormat&&e.alwaysFormat,this.resetRegExp()}},{key:"reset",value:function(){this.options&&this.init(this.options)}},{key:"resetRegExp",value:function(){var t="".concat(this.prefix,"(.+?)").concat(this.suffix);this.regexp=new RegExp(t,"g");var e="".concat(this.prefix).concat(this.unescapePrefix,"(.+?)").concat(this.unescapeSuffix).concat(this.suffix);this.regexpUnescape=new RegExp(e,"g");var n="".concat(this.nestingPrefix,"(.+?)").concat(this.nestingSuffix);this.nestingRegexp=new RegExp(n,"g")}},{key:"interpolate",value:function(t,e,n,r){var o,i,a,s=this,u=this.options&&this.options.interpolation&&this.options.interpolation.defaultVariables||{};function c(t){return t.replace(/\$/g,"$$$$")}var l=function(t){if(t.indexOf(s.formatSeparator)<0){var o=j(e,u,t);return s.alwaysFormat?s.format(o,void 0,n,rt(rt(rt({},r),e),{},{interpolationkey:t})):o}var i=t.split(s.formatSeparator),a=i.shift().trim(),c=i.join(s.formatSeparator).trim();return s.format(j(e,u,a),c,n,rt(rt(rt({},r),e),{},{interpolationkey:a}))};this.resetRegExp();var d=r&&r.missingInterpolationHandler||this.options.missingInterpolationHandler,p=r&&r.interpolation&&void 0!==r.interpolation.skipOnVariables?r.interpolation.skipOnVariables:this.options.interpolation.skipOnVariables;return[{regex:this.regexpUnescape,safeValue:function(t){return c(t)}},{regex:this.regexp,safeValue:function(t){return s.escapeValue?c(s.escape(t)):c(t)}}].forEach((function(e){for(a=0;o=e.regex.exec(t);){var n=o[1].trim();if(void 0===(i=l(n)))if("function"==typeof d){var u=d(t,o,r);i="string"==typeof u?u:""}else if(r&&r.hasOwnProperty(n))i="";else{if(p){i=o[0];continue}s.logger.warn("missed to pass in variable ".concat(n," for interpolating ").concat(t)),i=""}else"string"==typeof i||s.useRawValueToEscape||(i=P(i));var c=e.safeValue(i);if(t=t.replace(o[0],c),p?(e.regex.lastIndex+=i.length,e.regex.lastIndex-=o[0].length):e.regex.lastIndex=0,++a>=s.maxReplaces)break}})),t}},{key:"nest",value:function(t,e){var n,r,o=this,i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},a=rt({},i);function s(t,e){var n=this.nestingOptionsSeparator;if(t.indexOf(n)<0)return t;var r=t.split(new RegExp("".concat(n,"[ ]*{"))),o="{".concat(r[1]);t=r[0];var i=(o=this.interpolate(o,a)).match(/'/g),s=o.match(/"/g);(i&&i.length%2==0&&!s||s.length%2!=0)&&(o=o.replace(/'/g,'"'));try{a=JSON.parse(o),e&&(a=rt(rt({},e),a))}catch(e){return this.logger.warn("failed parsing options string in nesting for key ".concat(t),e),"".concat(t).concat(n).concat(o)}return delete a.defaultValue,t}for(a.applyPostProcessor=!1,delete a.defaultValue;n=this.nestingRegexp.exec(t);){var u=[],c=!1;if(-1!==n[0].indexOf(this.formatSeparator)&&!/{.*}/.test(n[1])){var l=n[1].split(this.formatSeparator).map((function(t){return t.trim()}));n[1]=l.shift(),u=l,c=!0}if((r=e(s.call(this,n[1].trim(),a),a))&&n[0]===t&&"string"!=typeof r)return r;"string"!=typeof r&&(r=P(r)),r||(this.logger.warn("missed to resolve ".concat(n[1]," for nesting ").concat(t)),r=""),c&&(r=u.reduce((function(t,e){return o.format(t,e,i.lng,rt(rt({},i),{},{interpolationkey:n[1].trim()}))}),r.trim())),t=t.replace(n[0],r),this.regexp.lastIndex=0}return t}}]),t}();function it(t,e){var n=Object.keys(t);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(t);e&&(r=r.filter((function(e){return Object.getOwnPropertyDescriptor(t,e).enumerable}))),n.push.apply(n,r)}return n}function at(t){for(var e=1;e<arguments.length;e++){var n=null!=arguments[e]?arguments[e]:{};e%2?it(Object(n),!0).forEach((function(e){w.default(t,e,n[e])})):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(n)):it(Object(n)).forEach((function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(n,e))}))}return t}function st(t){var e={};return function(n,r,o){var i=r+JSON.stringify(o),a=e[i];return a||(a=t(r,o),e[i]=a),a(n)}}var ut=function(){function t(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};h.default(this,t),this.logger=E.create("formatter"),this.options=e,this.formats={number:st((function(t,e){var n=new Intl.NumberFormat(t,e);return function(t){return n.format(t)}})),currency:st((function(t,e){var n=new Intl.NumberFormat(t,at(at({},e),{},{style:"currency"}));return function(t){return n.format(t)}})),datetime:st((function(t,e){var n=new Intl.DateTimeFormat(t,at({},e));return function(t){return n.format(t)}})),relativetime:st((function(t,e){var n=new Intl.RelativeTimeFormat(t,at({},e));return function(t){return n.format(t,e.range||"day")}})),list:st((function(t,e){var n=new Intl.ListFormat(t,at({},e));return function(t){return n.format(t)}}))},this.init(e)}return g.default(t,[{key:"init",value:function(t){var e=(arguments.length>1&&void 0!==arguments[1]?arguments[1]:{interpolation:{}}).interpolation;this.formatSeparator=e.formatSeparator?e.formatSeparator:e.formatSeparator||","}},{key:"add",value:function(t,e){this.formats[t.toLowerCase().trim()]=e}},{key:"addCached",value:function(t,e){this.formats[t.toLowerCase().trim()]=st(e)}},{key:"format",value:function(t,e,n,r){var o=this;return e.split(this.formatSeparator).reduce((function(t,e){var i=function(t){var e=t.toLowerCase().trim(),n={};if(t.indexOf("(")>-1){var r=t.split("(");e=r[0].toLowerCase().trim();var o=r[1].substring(0,r[1].length-1);"currency"===e&&o.indexOf(":")<0?n.currency||(n.currency=o.trim()):"relativetime"===e&&o.indexOf(":")<0?n.range||(n.range=o.trim()):o.split(";").forEach((function(t){if(t){var e=t.split(":"),r=k.default(e),o=r[0],i=r.slice(1).join(":").trim().replace(/^'+|'+$/g,"");n[o.trim()]||(n[o.trim()]=i),"false"===i&&(n[o.trim()]=!1),"true"===i&&(n[o.trim()]=!0),isNaN(i)||(n[o.trim()]=parseInt(i,10))}}))}return{formatName:e,formatOptions:n}}(e),a=i.formatName,s=i.formatOptions;if(o.formats[a]){var u=t;try{var c=r&&r.formatParams&&r.formatParams[r.interpolationkey]||{},l=c.locale||c.lng||r.locale||r.lng||n;u=o.formats[a](t,l,at(at(at({},s),r),c))}catch(t){o.logger.warn(t)}return u}return o.logger.warn("there was no format function for ".concat(a)),t}),t)}}]),t}();function ct(t,e){var n=Object.keys(t);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(t);e&&(r=r.filter((function(e){return Object.getOwnPropertyDescriptor(t,e).enumerable}))),n.push.apply(n,r)}return n}function lt(t){for(var e=1;e<arguments.length;e++){var n=null!=arguments[e]?arguments[e]:{};e%2?ct(Object(n),!0).forEach((function(e){w.default(t,e,n[e])})):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(n)):ct(Object(n)).forEach((function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(n,e))}))}return t}var dt=function(t){v.default(o,t);var e,n,r=(e=o,n=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}(),function(){var t,r=y.default(e);if(n){var o=y.default(this).constructor;t=Reflect.construct(r,arguments,o)}else t=r.apply(this,arguments);return b.default(this,t)});function o(t,e,n){var i,a=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return h.default(this,o),i=r.call(this),T&&x.call(m.default(i)),i.backend=t,i.store=e,i.services=n,i.languageUtils=n.languageUtils,i.options=a,i.logger=E.create("backendConnector"),i.waitingReads=[],i.maxParallelReads=a.maxParallelReads||10,i.readingCalls=0,i.maxRetries=a.maxRetries>=0?a.maxRetries:5,i.retryTimeout=a.retryTimeout>=1?a.retryTimeout:350,i.state={},i.queue=[],i.backend&&i.backend.init&&i.backend.init(n,a.backend,a),i}return g.default(o,[{key:"queueLoad",value:function(t,e,n,r){var o=this,i={},a={},s={},u={};return t.forEach((function(t){var r=!0;e.forEach((function(e){var s="".concat(t,"|").concat(e);!n.reload&&o.store.hasResourceBundle(t,e)?o.state[s]=2:o.state[s]<0||(1===o.state[s]?void 0===a[s]&&(a[s]=!0):(o.state[s]=1,r=!1,void 0===a[s]&&(a[s]=!0),void 0===i[s]&&(i[s]=!0),void 0===u[e]&&(u[e]=!0)))})),r||(s[t]=!0)})),(Object.keys(i).length||Object.keys(a).length)&&this.queue.push({pending:a,pendingCount:Object.keys(a).length,loaded:{},errors:[],callback:r}),{toLoad:Object.keys(i),pending:Object.keys(a),toLoadLanguages:Object.keys(s),toLoadNamespaces:Object.keys(u)}}},{key:"loaded",value:function(t,e,n){var r=t.split("|"),o=r[0],i=r[1];e&&this.emit("failedLoading",o,i,e),n&&this.store.addResourceBundle(o,i,n),this.state[t]=e?-1:2;var a={};this.queue.forEach((function(n){var r,s,u,c,l;r=n.loaded,s=i,(c=(u=C(r,[o],Object)).obj)[l=u.k]=c[l]||[],c[l].push(s),function(t,e){void 0!==t.pending[e]&&(delete t.pending[e],t.pendingCount--)}(n,t),e&&n.errors.push(e),0!==n.pendingCount||n.done||(Object.keys(n.loaded).forEach((function(t){a[t]||(a[t]={});var e=n.loaded[t];e.length&&e.forEach((function(e){void 0===a[t][e]&&(a[t][e]=!0)}))})),n.done=!0,n.errors.length?n.callback(n.errors):n.callback())})),this.emit("loaded",a),this.queue=this.queue.filter((function(t){return!t.done}))}},{key:"read",value:function(t,e,n){var r=this,o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:0,i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:this.retryTimeout,a=arguments.length>5?arguments[5]:void 0;return t.length?this.readingCalls>=this.maxParallelReads?void this.waitingReads.push({lng:t,ns:e,fcName:n,tried:o,wait:i,callback:a}):(this.readingCalls++,this.backend[n](t,e,(function(s,u){if(r.readingCalls--,r.waitingReads.length>0){var c=r.waitingReads.shift();r.read(c.lng,c.ns,c.fcName,c.tried,c.wait,c.callback)}s&&u&&o<r.maxRetries?setTimeout((function(){r.read.call(r,t,e,n,o+1,2*i,a)}),i):a(s,u)}))):a(null,{})}},{key:"prepareLoading",value:function(t,e){var n=this,r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},o=arguments.length>3?arguments[3]:void 0;if(!this.backend)return this.logger.warn("No backend was added via i18next.use. Will not load resources."),o&&o();"string"==typeof t&&(t=this.languageUtils.toResolveHierarchy(t)),"string"==typeof e&&(e=[e]);var i=this.queueLoad(t,e,r,o);if(!i.toLoad.length)return i.pending.length||o(),null;i.toLoad.forEach((function(t){n.loadOne(t)}))}},{key:"load",value:function(t,e,n){this.prepareLoading(t,e,{},n)}},{key:"reload",value:function(t,e,n){this.prepareLoading(t,e,{reload:!0},n)}},{key:"loadOne",value:function(t){var e=this,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"",r=t.split("|"),o=r[0],i=r[1];this.read(o,i,"read",void 0,void 0,(function(r,a){r&&e.logger.warn("".concat(n,"loading namespace ").concat(i," for language ").concat(o," failed"),r),!r&&a&&e.logger.log("".concat(n,"loaded namespace ").concat(i," for language ").concat(o),a),e.loaded(t,r,a)}))}},{key:"saveMissing",value:function(t,e,n,r,o){var i=arguments.length>5&&void 0!==arguments[5]?arguments[5]:{};this.services.utils&&this.services.utils.hasLoadedNamespace&&!this.services.utils.hasLoadedNamespace(e)?this.logger.warn('did not save key "'.concat(n,'" as the namespace "').concat(e,'" was not yet loaded'),"This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!"):null!=n&&""!==n&&(this.backend&&this.backend.create&&this.backend.create(t,e,n,r,null,lt(lt({},i),{},{isUpdate:o})),t&&t[0]&&this.store.addResource(t[0],e,n,r))}}]),o}(x);function pt(t){return"string"==typeof t.ns&&(t.ns=[t.ns]),"string"==typeof t.fallbackLng&&(t.fallbackLng=[t.fallbackLng]),"string"==typeof t.fallbackNS&&(t.fallbackNS=[t.fallbackNS]),t.supportedLngs&&t.supportedLngs.indexOf("cimode")<0&&(t.supportedLngs=t.supportedLngs.concat(["cimode"])),t}function ft(t,e){var n=Object.keys(t);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(t);e&&(r=r.filter((function(e){return Object.getOwnPropertyDescriptor(t,e).enumerable}))),n.push.apply(n,r)}return n}function ht(t){for(var e=1;e<arguments.length;e++){var n=null!=arguments[e]?arguments[e]:{};e%2?ft(Object(n),!0).forEach((function(e){w.default(t,e,n[e])})):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(n)):ft(Object(n)).forEach((function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(n,e))}))}return t}function gt(){}var mt=function(t){v.default(o,t);var e,n,r=(e=o,n=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}(),function(){var t,r=y.default(e);if(n){var o=y.default(this).constructor;t=Reflect.construct(r,arguments,o)}else t=r.apply(this,arguments);return b.default(this,t)});function o(){var t,e,n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},i=arguments.length>1?arguments[1]:void 0;if(h.default(this,o),t=r.call(this),T&&x.call(m.default(t)),t.options=pt(n),t.services={},t.logger=E,t.modules={external:[]},e=m.default(t),Object.getOwnPropertyNames(Object.getPrototypeOf(e)).forEach((function(t){"function"==typeof e[t]&&(e[t]=e[t].bind(e))})),i&&!t.isInitialized&&!n.isClone){if(!t.options.initImmediate)return t.init(n,i),b.default(t,m.default(t));setTimeout((function(){t.init(n,i)}),0)}return t}return g.default(o,[{key:"init",value:function(){var t=this,e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},n=arguments.length>1?arguments[1]:void 0;"function"==typeof e&&(n=e,e={}),!e.defaultNS&&!1!==e.defaultNS&&e.ns&&("string"==typeof e.ns?e.defaultNS=e.ns:e.ns.indexOf("translation")<0&&(e.defaultNS=e.ns[0]));var r={debug:!1,initImmediate:!0,ns:["translation"],defaultNS:["translation"],fallbackLng:["dev"],fallbackNS:!1,supportedLngs:!1,nonExplicitSupportedLngs:!1,load:"all",preload:!1,simplifyPluralSuffix:!0,keySeparator:".",nsSeparator:":",pluralSeparator:"_",contextSeparator:"_",partialBundledLanguages:!1,saveMissing:!1,updateMissing:!1,saveMissingTo:"fallback",saveMissingPlurals:!0,missingKeyHandler:!1,missingInterpolationHandler:!1,postProcess:!1,postProcessPassResolved:!1,returnNull:!0,returnEmptyString:!0,returnObjects:!1,joinArrays:!1,returnedObjectHandler:!1,parseMissingKeyHandler:!1,appendNamespaceToMissingKey:!1,appendNamespaceToCIMode:!1,overloadTranslationOptionHandler:function(t){var e={};if("object"===f.default(t[1])&&(e=t[1]),"string"==typeof t[1]&&(e.defaultValue=t[1]),"string"==typeof t[2]&&(e.tDescription=t[2]),"object"===f.default(t[2])||"object"===f.default(t[3])){var n=t[3]||t[2];Object.keys(n).forEach((function(t){e[t]=n[t]}))}return e},interpolation:{escapeValue:!0,format:function(t,e,n,r){return t},prefix:"{{",suffix:"}}",formatSeparator:",",unescapePrefix:"-",nestingPrefix:"$t(",nestingSuffix:")",nestingOptionsSeparator:",",maxReplaces:1e3,skipOnVariables:!0}};function o(t){return t?"function"==typeof t?new t:t:null}if(this.options=ht(ht(ht({},r),this.options),pt(e)),"v1"!==this.options.compatibilityAPI&&(this.options.interpolation=ht(ht({},r.interpolation),this.options.interpolation)),void 0!==e.keySeparator&&(this.options.userDefinedKeySeparator=e.keySeparator),void 0!==e.nsSeparator&&(this.options.userDefinedNsSeparator=e.nsSeparator),!this.options.isClone){var i;this.modules.logger?E.init(o(this.modules.logger),this.options):E.init(null,this.options),this.modules.formatter?i=this.modules.formatter:"undefined"!=typeof Intl&&(i=ut);var a=new Y(this.options);this.store=new W(this.options.resources,this.options);var s=this.services;s.logger=E,s.resourceStore=this.store,s.languageUtils=a,s.pluralResolver=new et(a,{prepend:this.options.pluralSeparator,compatibilityJSON:this.options.compatibilityJSON,simplifyPluralSuffix:this.options.simplifyPluralSuffix}),!i||this.options.interpolation.format&&this.options.interpolation.format!==r.interpolation.format||(s.formatter=o(i),s.formatter.init(s,this.options),this.options.interpolation.format=s.formatter.format.bind(s.formatter)),s.interpolator=new ot(this.options),s.utils={hasLoadedNamespace:this.hasLoadedNamespace.bind(this)},s.backendConnector=new dt(o(this.modules.backend),s.resourceStore,s,this.options),s.backendConnector.on("*",(function(e){for(var n=arguments.length,r=new Array(n>1?n-1:0),o=1;o<n;o++)r[o-1]=arguments[o];t.emit.apply(t,[e].concat(r))})),this.modules.languageDetector&&(s.languageDetector=o(this.modules.languageDetector),s.languageDetector.init(s,this.options.detection,this.options)),this.modules.i18nFormat&&(s.i18nFormat=o(this.modules.i18nFormat),s.i18nFormat.init&&s.i18nFormat.init(this)),this.translator=new K(this.services,this.options),this.translator.on("*",(function(e){for(var n=arguments.length,r=new Array(n>1?n-1:0),o=1;o<n;o++)r[o-1]=arguments[o];t.emit.apply(t,[e].concat(r))})),this.modules.external.forEach((function(e){e.init&&e.init(t)}))}if(this.format=this.options.interpolation.format,n||(n=gt),this.options.fallbackLng&&!this.services.languageDetector&&!this.options.lng){var u=this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);u.length>0&&"dev"!==u[0]&&(this.options.lng=u[0])}this.services.languageDetector||this.options.lng||this.logger.warn("init: no languageDetector is used and no lng is defined"),["getResource","hasResourceBundle","getResourceBundle","getDataByLanguage"].forEach((function(e){t[e]=function(){var n;return(n=t.store)[e].apply(n,arguments)}})),["addResource","addResources","addResourceBundle","removeResourceBundle"].forEach((function(e){t[e]=function(){var n;return(n=t.store)[e].apply(n,arguments),t}}));var c=R(),l=function(){var e=function(e,r){t.isInitialized&&!t.initializedStoreOnce&&t.logger.warn("init: i18next is already initialized. You should call init just once!"),t.isInitialized=!0,t.options.isClone||t.logger.log("initialized",t.options),t.emit("initialized",t.options),c.resolve(r),n(e,r)};if(t.languages&&"v1"!==t.options.compatibilityAPI&&!t.isInitialized)return e(null,t.t.bind(t));t.changeLanguage(t.options.lng,e)};return this.options.resources||!this.options.initImmediate?l():setTimeout(l,0),c}},{key:"loadResources",value:function(t){var e=this,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:gt,r="string"==typeof t?t:this.language;if("function"==typeof t&&(n=t),!this.options.resources||this.options.partialBundledLanguages){if(r&&"cimode"===r.toLowerCase())return n();var o=[],i=function(t){t&&e.services.languageUtils.toResolveHierarchy(t).forEach((function(t){o.indexOf(t)<0&&o.push(t)}))};r?i(r):this.services.languageUtils.getFallbackCodes(this.options.fallbackLng).forEach((function(t){return i(t)})),this.options.preload&&this.options.preload.forEach((function(t){return i(t)})),this.services.backendConnector.load(o,this.options.ns,(function(t){t||e.resolvedLanguage||!e.language||e.setResolvedLanguage(e.language),n(t)}))}else n(null)}},{key:"reloadResources",value:function(t,e,n){var r=R();return t||(t=this.languages),e||(e=this.options.ns),n||(n=gt),this.services.backendConnector.reload(t,e,(function(t){r.resolve(),n(t)})),r}},{key:"use",value:function(t){if(!t)throw new Error("You are passing an undefined module! Please check the object you are passing to i18next.use()");if(!t.type)throw new Error("You are passing a wrong module! Please check the object you are passing to i18next.use()");return"backend"===t.type&&(this.modules.backend=t),("logger"===t.type||t.log&&t.warn&&t.error)&&(this.modules.logger=t),"languageDetector"===t.type&&(this.modules.languageDetector=t),"i18nFormat"===t.type&&(this.modules.i18nFormat=t),"postProcessor"===t.type&&z.addPostProcessor(t),"formatter"===t.type&&(this.modules.formatter=t),"3rdParty"===t.type&&this.modules.external.push(t),this}},{key:"setResolvedLanguage",value:function(t){if(t&&this.languages&&!(["cimode","dev"].indexOf(t)>-1))for(var e=0;e<this.languages.length;e++){var n=this.languages[e];if(!(["cimode","dev"].indexOf(n)>-1)&&this.store.hasLanguageSomeTranslations(n)){this.resolvedLanguage=n;break}}}},{key:"changeLanguage",value:function(t,e){var n=this;this.isLanguageChangingTo=t;var r=R();this.emit("languageChanging",t);var o=function(t){n.language=t,n.languages=n.services.languageUtils.toResolveHierarchy(t),n.resolvedLanguage=void 0,n.setResolvedLanguage(t)},i=function(i){t||i||!n.services.languageDetector||(i=[]);var a="string"==typeof i?i:n.services.languageUtils.getBestMatchFromCodes(i);a&&(n.language||o(a),n.translator.language||n.translator.changeLanguage(a),n.services.languageDetector&&n.services.languageDetector.cacheUserLanguage(a)),n.loadResources(a,(function(t){!function(t,i){i?(o(i),n.translator.changeLanguage(i),n.isLanguageChangingTo=void 0,n.emit("languageChanged",i),n.logger.log("languageChanged",i)):n.isLanguageChangingTo=void 0,r.resolve((function(){return n.t.apply(n,arguments)})),e&&e(t,(function(){return n.t.apply(n,arguments)}))}(t,a)}))};return t||!this.services.languageDetector||this.services.languageDetector.async?!t&&this.services.languageDetector&&this.services.languageDetector.async?this.services.languageDetector.detect(i):i(t):i(this.services.languageDetector.detect()),r}},{key:"getFixedT",value:function(t,e,n){var r=this,o=function t(e,o){var i;if("object"!==f.default(o)){for(var a=arguments.length,s=new Array(a>2?a-2:0),u=2;u<a;u++)s[u-2]=arguments[u];i=r.options.overloadTranslationOptionHandler([e,o].concat(s))}else i=ht({},o);i.lng=i.lng||t.lng,i.lngs=i.lngs||t.lngs,i.ns=i.ns||t.ns,i.keyPrefix=i.keyPrefix||n||t.keyPrefix;var c=r.options.keySeparator||".",l=i.keyPrefix?"".concat(i.keyPrefix).concat(c).concat(e):e;return r.t(l,i)};return"string"==typeof t?o.lng=t:o.lngs=t,o.ns=e,o.keyPrefix=n,o}},{key:"t",value:function(){var t;return this.translator&&(t=this.translator).translate.apply(t,arguments)}},{key:"exists",value:function(){var t;return this.translator&&(t=this.translator).exists.apply(t,arguments)}},{key:"setDefaultNamespace",value:function(t){this.options.defaultNS=t}},{key:"hasLoadedNamespace",value:function(t){var e=this,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(!this.isInitialized)return this.logger.warn("hasLoadedNamespace: i18next was not initialized",this.languages),!1;if(!this.languages||!this.languages.length)return this.logger.warn("hasLoadedNamespace: i18n.languages were undefined or empty",this.languages),!1;var r=this.resolvedLanguage||this.languages[0],o=!!this.options&&this.options.fallbackLng,i=this.languages[this.languages.length-1];if("cimode"===r.toLowerCase())return!0;var a=function(t,n){var r=e.services.backendConnector.state["".concat(t,"|").concat(n)];return-1===r||2===r};if(n.precheck){var s=n.precheck(this,a);if(void 0!==s)return s}return!(!this.hasResourceBundle(r,t)&&this.services.backendConnector.backend&&(!this.options.resources||this.options.partialBundledLanguages)&&(!a(r,t)||o&&!a(i,t)))}},{key:"loadNamespaces",value:function(t,e){var n=this,r=R();return this.options.ns?("string"==typeof t&&(t=[t]),t.forEach((function(t){n.options.ns.indexOf(t)<0&&n.options.ns.push(t)})),this.loadResources((function(t){r.resolve(),e&&e(t)})),r):(e&&e(),Promise.resolve())}},{key:"loadLanguages",value:function(t,e){var n=R();"string"==typeof t&&(t=[t]);var r=this.options.preload||[],o=t.filter((function(t){return r.indexOf(t)<0}));return o.length?(this.options.preload=r.concat(o),this.loadResources((function(t){n.resolve(),e&&e(t)})),n):(e&&e(),Promise.resolve())}},{key:"dir",value:function(t){return t||(t=this.resolvedLanguage||(this.languages&&this.languages.length>0?this.languages[0]:this.language)),t?["ar","shu","sqr","ssh","xaa","yhd","yud","aao","abh","abv","acm","acq","acw","acx","acy","adf","ads","aeb","aec","afb","ajp","apc","apd","arb","arq","ars","ary","arz","auz","avl","ayh","ayl","ayn","ayp","bbz","pga","he","iw","ps","pbt","pbu","pst","prp","prd","ug","ur","ydd","yds","yih","ji","yi","hbo","men","xmn","fa","jpr","peo","pes","prs","dv","sam","ckb"].indexOf(this.services.languageUtils.getLanguagePartFromCode(t))>-1||t.toLowerCase().indexOf("-arab")>1?"rtl":"ltr":"rtl"}},{key:"cloneInstance",value:function(){var t=this,e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:gt,r=ht(ht(ht({},this.options),e),{isClone:!0}),i=new o(r);return void 0===e.debug&&void 0===e.prefix||(i.logger=i.logger.clone(e)),["store","services","language"].forEach((function(e){i[e]=t[e]})),i.services=ht({},this.services),i.services.utils={hasLoadedNamespace:i.hasLoadedNamespace.bind(i)},i.translator=new K(i.services,i.options),i.translator.on("*",(function(t){for(var e=arguments.length,n=new Array(e>1?e-1:0),r=1;r<e;r++)n[r-1]=arguments[r];i.emit.apply(i,[t].concat(n))})),i.init(r,n),i.translator.options=i.options,i.translator.backendConnector.services.utils={hasLoadedNamespace:i.hasLoadedNamespace.bind(i)},i}},{key:"toJSON",value:function(){return{options:this.options,store:this.store,language:this.language,languages:this.languages,resolvedLanguage:this.resolvedLanguage}}}]),o}(x);w.default(mt,"createInstance",(function(){return new mt(arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},arguments.length>1?arguments[1]:void 0)}));var vt=mt.createInstance();vt.createInstance=mt.createInstance,t.exports=vt},1016:function(t,e,n){"use strict";n.r(e)},3188:function(t){"use strict";function e(t){return t instanceof Buffer?Buffer.from(t):new t.constructor(t.buffer.slice(),t.byteOffset,t.length)}t.exports=function(t){return(t=t||{}).circles?function(t){var n=[],r=[];return t.proto?function t(i){if("object"!=typeof i||null===i)return i;if(i instanceof Date)return new Date(i);if(Array.isArray(i))return o(i,t);if(i instanceof Map)return new Map(o(Array.from(i),t));if(i instanceof Set)return new Set(o(Array.from(i),t));var a={};for(var s in n.push(i),r.push(a),i){var u=i[s];if("object"!=typeof u||null===u)a[s]=u;else if(u instanceof Date)a[s]=new Date(u);else if(u instanceof Map)a[s]=new Map(o(Array.from(u),t));else if(u instanceof Set)a[s]=new Set(o(Array.from(u),t));else if(ArrayBuffer.isView(u))a[s]=e(u);else{var c=n.indexOf(u);a[s]=-1!==c?r[c]:t(u)}}return n.pop(),r.pop(),a}:function t(i){if("object"!=typeof i||null===i)return i;if(i instanceof Date)return new Date(i);if(Array.isArray(i))return o(i,t);if(i instanceof Map)return new Map(o(Array.from(i),t));if(i instanceof Set)return new Set(o(Array.from(i),t));var a={};for(var s in n.push(i),r.push(a),i)if(!1!==Object.hasOwnProperty.call(i,s)){var u=i[s];if("object"!=typeof u||null===u)a[s]=u;else if(u instanceof Date)a[s]=new Date(u);else if(u instanceof Map)a[s]=new Map(o(Array.from(u),t));else if(u instanceof Set)a[s]=new Set(o(Array.from(u),t));else if(ArrayBuffer.isView(u))a[s]=e(u);else{var c=n.indexOf(u);a[s]=-1!==c?r[c]:t(u)}}return n.pop(),r.pop(),a};function o(t,o){for(var i=Object.keys(t),a=new Array(i.length),s=0;s<i.length;s++){var u=i[s],c=t[u];if("object"!=typeof c||null===c)a[u]=c;else if(c instanceof Date)a[u]=new Date(c);else if(ArrayBuffer.isView(c))a[u]=e(c);else{var l=n.indexOf(c);a[u]=-1!==l?r[l]:o(c)}}return a}}(t):t.proto?function t(r){if("object"!=typeof r||null===r)return r;if(r instanceof Date)return new Date(r);if(Array.isArray(r))return n(r,t);if(r instanceof Map)return new Map(n(Array.from(r),t));if(r instanceof Set)return new Set(n(Array.from(r),t));var o={};for(var i in r){var a=r[i];"object"!=typeof a||null===a?o[i]=a:a instanceof Date?o[i]=new Date(a):a instanceof Map?o[i]=new Map(n(Array.from(a),t)):a instanceof Set?o[i]=new Set(n(Array.from(a),t)):ArrayBuffer.isView(a)?o[i]=e(a):o[i]=t(a)}return o}:function t(r){if("object"!=typeof r||null===r)return r;if(r instanceof Date)return new Date(r);if(Array.isArray(r))return n(r,t);if(r instanceof Map)return new Map(n(Array.from(r),t));if(r instanceof Set)return new Set(n(Array.from(r),t));var o={};for(var i in r)if(!1!==Object.hasOwnProperty.call(r,i)){var a=r[i];"object"!=typeof a||null===a?o[i]=a:a instanceof Date?o[i]=new Date(a):a instanceof Map?o[i]=new Map(n(Array.from(a),t)):a instanceof Set?o[i]=new Set(n(Array.from(a),t)):ArrayBuffer.isView(a)?o[i]=e(a):o[i]=t(a)}return o};function n(t,n){for(var r=Object.keys(t),o=new Array(r.length),i=0;i<r.length;i++){var a=r[i],s=t[a];"object"!=typeof s||null===s?o[a]=s:s instanceof Date?o[a]=new Date(s):ArrayBuffer.isView(s)?o[a]=e(s):o[a]=n(s)}return o}}},7429:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),Object.defineProperty(e,"NIL",{enumerable:!0,get:function(){return s.default}}),Object.defineProperty(e,"parse",{enumerable:!0,get:function(){return d.default}}),Object.defineProperty(e,"stringify",{enumerable:!0,get:function(){return l.default}}),Object.defineProperty(e,"v1",{enumerable:!0,get:function(){return r.default}}),Object.defineProperty(e,"v3",{enumerable:!0,get:function(){return o.default}}),Object.defineProperty(e,"v4",{enumerable:!0,get:function(){return i.default}}),Object.defineProperty(e,"v5",{enumerable:!0,get:function(){return a.default}}),Object.defineProperty(e,"validate",{enumerable:!0,get:function(){return c.default}}),Object.defineProperty(e,"version",{enumerable:!0,get:function(){return u.default}});var r=p(n(3990)),o=p(n(8237)),i=p(n(5355)),a=p(n(3764)),s=p(n(6314)),u=p(n(8464)),c=p(n(6435)),l=p(n(4008)),d=p(n(8222));function p(t){return t&&t.__esModule?t:{default:t}}},4163:function(t,e){"use strict";function n(t){return 14+(t+64>>>9<<4)+1}function r(t,e){const n=(65535&t)+(65535&e);return(t>>16)+(e>>16)+(n>>16)<<16|65535&n}function o(t,e,n,o,i,a){return r((s=r(r(e,t),r(o,a)))<<(u=i)|s>>>32-u,n);var s,u}function i(t,e,n,r,i,a,s){return o(e&n|~e&r,t,e,i,a,s)}function a(t,e,n,r,i,a,s){return o(e&r|n&~r,t,e,i,a,s)}function s(t,e,n,r,i,a,s){return o(e^n^r,t,e,i,a,s)}function u(t,e,n,r,i,a,s){return o(n^(e|~r),t,e,i,a,s)}Object.defineProperty(e,"__esModule",{value:!0}),e.default=void 0;e.default=function(t){if("string"==typeof t){const e=unescape(encodeURIComponent(t));t=new Uint8Array(e.length);for(let n=0;n<e.length;++n)t[n]=e.charCodeAt(n)}return function(t){const e=[],n=32*t.length,r="0123456789abcdef";for(let o=0;o<n;o+=8){const n=t[o>>5]>>>o%32&255,i=parseInt(r.charAt(n>>>4&15)+r.charAt(15&n),16);e.push(i)}return e}(function(t,e){t[e>>5]|=128<<e%32,t[n(e)-1]=e;let o=1732584193,c=-271733879,l=-1732584194,d=271733878;for(let e=0;e<t.length;e+=16){const n=o,p=c,f=l,h=d;o=i(o,c,l,d,t[e],7,-680876936),d=i(d,o,c,l,t[e+1],12,-389564586),l=i(l,d,o,c,t[e+2],17,606105819),c=i(c,l,d,o,t[e+3],22,-1044525330),o=i(o,c,l,d,t[e+4],7,-176418897),d=i(d,o,c,l,t[e+5],12,1200080426),l=i(l,d,o,c,t[e+6],17,-1473231341),c=i(c,l,d,o,t[e+7],22,-45705983),o=i(o,c,l,d,t[e+8],7,1770035416),d=i(d,o,c,l,t[e+9],12,-1958414417),l=i(l,d,o,c,t[e+10],17,-42063),c=i(c,l,d,o,t[e+11],22,-1990404162),o=i(o,c,l,d,t[e+12],7,1804603682),d=i(d,o,c,l,t[e+13],12,-40341101),l=i(l,d,o,c,t[e+14],17,-1502002290),c=i(c,l,d,o,t[e+15],22,1236535329),o=a(o,c,l,d,t[e+1],5,-165796510),d=a(d,o,c,l,t[e+6],9,-1069501632),l=a(l,d,o,c,t[e+11],14,643717713),c=a(c,l,d,o,t[e],20,-373897302),o=a(o,c,l,d,t[e+5],5,-701558691),d=a(d,o,c,l,t[e+10],9,38016083),l=a(l,d,o,c,t[e+15],14,-660478335),c=a(c,l,d,o,t[e+4],20,-405537848),o=a(o,c,l,d,t[e+9],5,568446438),d=a(d,o,c,l,t[e+14],9,-1019803690),l=a(l,d,o,c,t[e+3],14,-187363961),c=a(c,l,d,o,t[e+8],20,1163531501),o=a(o,c,l,d,t[e+13],5,-1444681467),d=a(d,o,c,l,t[e+2],9,-51403784),l=a(l,d,o,c,t[e+7],14,1735328473),c=a(c,l,d,o,t[e+12],20,-1926607734),o=s(o,c,l,d,t[e+5],4,-378558),d=s(d,o,c,l,t[e+8],11,-2022574463),l=s(l,d,o,c,t[e+11],16,1839030562),c=s(c,l,d,o,t[e+14],23,-35309556),o=s(o,c,l,d,t[e+1],4,-1530992060),d=s(d,o,c,l,t[e+4],11,1272893353),l=s(l,d,o,c,t[e+7],16,-155497632),c=s(c,l,d,o,t[e+10],23,-1094730640),o=s(o,c,l,d,t[e+13],4,681279174),d=s(d,o,c,l,t[e],11,-358537222),l=s(l,d,o,c,t[e+3],16,-722521979),c=s(c,l,d,o,t[e+6],23,76029189),o=s(o,c,l,d,t[e+9],4,-640364487),d=s(d,o,c,l,t[e+12],11,-421815835),l=s(l,d,o,c,t[e+15],16,530742520),c=s(c,l,d,o,t[e+2],23,-995338651),o=u(o,c,l,d,t[e],6,-198630844),d=u(d,o,c,l,t[e+7],10,1126891415),l=u(l,d,o,c,t[e+14],15,-1416354905),c=u(c,l,d,o,t[e+5],21,-57434055),o=u(o,c,l,d,t[e+12],6,1700485571),d=u(d,o,c,l,t[e+3],10,-1894986606),l=u(l,d,o,c,t[e+10],15,-1051523),c=u(c,l,d,o,t[e+1],21,-2054922799),o=u(o,c,l,d,t[e+8],6,1873313359),d=u(d,o,c,l,t[e+15],10,-30611744),l=u(l,d,o,c,t[e+6],15,-1560198380),c=u(c,l,d,o,t[e+13],21,1309151649),o=u(o,c,l,d,t[e+4],6,-145523070),d=u(d,o,c,l,t[e+11],10,-1120210379),l=u(l,d,o,c,t[e+2],15,718787259),c=u(c,l,d,o,t[e+9],21,-343485551),o=r(o,n),c=r(c,p),l=r(l,f),d=r(d,h)}return[o,c,l,d]}(function(t){if(0===t.length)return[];const e=8*t.length,r=new Uint32Array(n(e));for(let n=0;n<e;n+=8)r[n>>5]|=(255&t[n/8])<<n%32;return r}(t),8*t.length))}},4790:function(t,e){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.default=void 0;var n={randomUUID:"undefined"!=typeof crypto&&crypto.randomUUID&&crypto.randomUUID.bind(crypto)};e.default=n},6314:function(t,e){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.default=void 0,e.default="00000000-0000-0000-0000-000000000000"},8222:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.default=void 0;var r,o=(r=n(6435))&&r.__esModule?r:{default:r};e.default=function(t){if(!(0,o.default)(t))throw TypeError("Invalid UUID");let e;const n=new Uint8Array(16);return n[0]=(e=parseInt(t.slice(0,8),16))>>>24,n[1]=e>>>16&255,n[2]=e>>>8&255,n[3]=255&e,n[4]=(e=parseInt(t.slice(9,13),16))>>>8,n[5]=255&e,n[6]=(e=parseInt(t.slice(14,18),16))>>>8,n[7]=255&e,n[8]=(e=parseInt(t.slice(19,23),16))>>>8,n[9]=255&e,n[10]=(e=parseInt(t.slice(24,36),16))/1099511627776&255,n[11]=e/4294967296&255,n[12]=e>>>24&255,n[13]=e>>>16&255,n[14]=e>>>8&255,n[15]=255&e,n}},58:function(t,e){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.default=void 0,e.default=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i},3319:function(t,e){"use strict";let n;Object.defineProperty(e,"__esModule",{value:!0}),e.default=function(){if(!n&&(n="undefined"!=typeof crypto&&crypto.getRandomValues&&crypto.getRandomValues.bind(crypto),!n))throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");return n(r)};const r=new Uint8Array(16)},3757:function(t,e){"use strict";function n(t,e,n,r){switch(t){case 0:return e&n^~e&r;case 1:case 3:return e^n^r;case 2:return e&n^e&r^n&r}}function r(t,e){return t<<e|t>>>32-e}Object.defineProperty(e,"__esModule",{value:!0}),e.default=void 0;e.default=function(t){const e=[1518500249,1859775393,2400959708,3395469782],o=[1732584193,4023233417,2562383102,271733878,3285377520];if("string"==typeof t){const e=unescape(encodeURIComponent(t));t=[];for(let n=0;n<e.length;++n)t.push(e.charCodeAt(n))}else Array.isArray(t)||(t=Array.prototype.slice.call(t));t.push(128);const i=t.length/4+2,a=Math.ceil(i/16),s=new Array(a);for(let e=0;e<a;++e){const n=new Uint32Array(16);for(let r=0;r<16;++r)n[r]=t[64*e+4*r]<<24|t[64*e+4*r+1]<<16|t[64*e+4*r+2]<<8|t[64*e+4*r+3];s[e]=n}s[a-1][14]=8*(t.length-1)/Math.pow(2,32),s[a-1][14]=Math.floor(s[a-1][14]),s[a-1][15]=8*(t.length-1)&4294967295;for(let t=0;t<a;++t){const i=new Uint32Array(80);for(let e=0;e<16;++e)i[e]=s[t][e];for(let t=16;t<80;++t)i[t]=r(i[t-3]^i[t-8]^i[t-14]^i[t-16],1);let a=o[0],u=o[1],c=o[2],l=o[3],d=o[4];for(let t=0;t<80;++t){const o=Math.floor(t/20),s=r(a,5)+n(o,u,c,l)+d+e[o]+i[t]>>>0;d=l,l=c,c=r(u,30)>>>0,u=a,a=s}o[0]=o[0]+a>>>0,o[1]=o[1]+u>>>0,o[2]=o[2]+c>>>0,o[3]=o[3]+l>>>0,o[4]=o[4]+d>>>0}return[o[0]>>24&255,o[0]>>16&255,o[0]>>8&255,255&o[0],o[1]>>24&255,o[1]>>16&255,o[1]>>8&255,255&o[1],o[2]>>24&255,o[2]>>16&255,o[2]>>8&255,255&o[2],o[3]>>24&255,o[3]>>16&255,o[3]>>8&255,255&o[3],o[4]>>24&255,o[4]>>16&255,o[4]>>8&255,255&o[4]]}},4008:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.default=void 0,e.unsafeStringify=a;var r,o=(r=n(6435))&&r.__esModule?r:{default:r};const i=[];for(let t=0;t<256;++t)i.push((t+256).toString(16).slice(1));function a(t,e=0){return(i[t[e+0]]+i[t[e+1]]+i[t[e+2]]+i[t[e+3]]+"-"+i[t[e+4]]+i[t[e+5]]+"-"+i[t[e+6]]+i[t[e+7]]+"-"+i[t[e+8]]+i[t[e+9]]+"-"+i[t[e+10]]+i[t[e+11]]+i[t[e+12]]+i[t[e+13]]+i[t[e+14]]+i[t[e+15]]).toLowerCase()}e.default=function(t,e=0){const n=a(t,e);if(!(0,o.default)(n))throw TypeError("Stringified UUID is invalid");return n}},3990:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.default=void 0;var r,o=(r=n(3319))&&r.__esModule?r:{default:r},i=n(4008);let a,s,u=0,c=0;e.default=function(t,e,n){let r=e&&n||0;const l=e||new Array(16);let d=(t=t||{}).node||a,p=void 0!==t.clockseq?t.clockseq:s;if(null==d||null==p){const e=t.random||(t.rng||o.default)();null==d&&(d=a=[1|e[0],e[1],e[2],e[3],e[4],e[5]]),null==p&&(p=s=16383&(e[6]<<8|e[7]))}let f=void 0!==t.msecs?t.msecs:Date.now(),h=void 0!==t.nsecs?t.nsecs:c+1;const g=f-u+(h-c)/1e4;if(g<0&&void 0===t.clockseq&&(p=p+1&16383),(g<0||f>u)&&void 0===t.nsecs&&(h=0),h>=1e4)throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");u=f,c=h,s=p,f+=122192928e5;const m=(1e4*(268435455&f)+h)%4294967296;l[r++]=m>>>24&255,l[r++]=m>>>16&255,l[r++]=m>>>8&255,l[r++]=255&m;const v=f/4294967296*1e4&268435455;l[r++]=v>>>8&255,l[r++]=255&v,l[r++]=v>>>24&15|16,l[r++]=v>>>16&255,l[r++]=p>>>8|128,l[r++]=255&p;for(let t=0;t<6;++t)l[r+t]=d[t];return e||(0,i.unsafeStringify)(l)}},8237:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.default=void 0;var r=i(n(7925)),o=i(n(4163));function i(t){return t&&t.__esModule?t:{default:t}}var a=(0,r.default)("v3",48,o.default);e.default=a},7925:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.URL=e.DNS=void 0,e.default=function(t,e,n){function r(t,r,a,s){var u;if("string"==typeof t&&(t=function(t){t=unescape(encodeURIComponent(t));const e=[];for(let n=0;n<t.length;++n)e.push(t.charCodeAt(n));return e}(t)),"string"==typeof r&&(r=(0,i.default)(r)),16!==(null===(u=r)||void 0===u?void 0:u.length))throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");let c=new Uint8Array(16+t.length);if(c.set(r),c.set(t,r.length),c=n(c),c[6]=15&c[6]|e,c[8]=63&c[8]|128,a){s=s||0;for(let t=0;t<16;++t)a[s+t]=c[t];return a}return(0,o.unsafeStringify)(c)}try{r.name=t}catch(t){}return r.DNS=a,r.URL=s,r};var r,o=n(4008),i=(r=n(8222))&&r.__esModule?r:{default:r};const a="6ba7b810-9dad-11d1-80b4-00c04fd430c8";e.DNS=a;const s="6ba7b811-9dad-11d1-80b4-00c04fd430c8";e.URL=s},5355:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.default=void 0;var r=a(n(4790)),o=a(n(3319)),i=n(4008);function a(t){return t&&t.__esModule?t:{default:t}}e.default=function(t,e,n){if(r.default.randomUUID&&!e&&!t)return r.default.randomUUID();const a=(t=t||{}).random||(t.rng||o.default)();if(a[6]=15&a[6]|64,a[8]=63&a[8]|128,e){n=n||0;for(let t=0;t<16;++t)e[n+t]=a[t];return e}return(0,i.unsafeStringify)(a)}},3764:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.default=void 0;var r=i(n(7925)),o=i(n(3757));function i(t){return t&&t.__esModule?t:{default:t}}var a=(0,r.default)("v5",80,o.default);e.default=a},6435:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.default=void 0;var r,o=(r=n(58))&&r.__esModule?r:{default:r};e.default=function(t){return"string"==typeof t&&o.default.test(t)}},8464:function(t,e,n){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.default=void 0;var r,o=(r=n(6435))&&r.__esModule?r:{default:r};e.default=function(t){if(!(0,o.default)(t))throw TypeError("Invalid UUID");return parseInt(t.slice(14,15),16)}},3897:function(t){t.exports=function(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,r=new Array(e);n<e;n++)r[n]=t[n];return r},t.exports.__esModule=!0,t.exports.default=t.exports},5372:function(t){t.exports=function(t){if(Array.isArray(t))return t},t.exports.__esModule=!0,t.exports.default=t.exports},6115:function(t){t.exports=function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t},t.exports.__esModule=!0,t.exports.default=t.exports},6690:function(t){t.exports=function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")},t.exports.__esModule=!0,t.exports.default=t.exports},9728:function(t,e,n){var r=n(4062);function o(t,e){for(var n=0;n<e.length;n++){var o=e[n];o.enumerable=o.enumerable||!1,o.configurable=!0,"value"in o&&(o.writable=!0),Object.defineProperty(t,r(o.key),o)}}t.exports=function(t,e,n){return e&&o(t.prototype,e),n&&o(t,n),Object.defineProperty(t,"prototype",{writable:!1}),t},t.exports.__esModule=!0,t.exports.default=t.exports},8416:function(t,e,n){var r=n(4062);t.exports=function(t,e,n){return(e=r(e))in t?Object.defineProperty(t,e,{value:n,enumerable:!0,configurable:!0,writable:!0}):t[e]=n,t},t.exports.__esModule=!0,t.exports.default=t.exports},3808:function(t){function e(n){return t.exports=e=Object.setPrototypeOf?Object.getPrototypeOf.bind():function(t){return t.__proto__||Object.getPrototypeOf(t)},t.exports.__esModule=!0,t.exports.default=t.exports,e(n)}t.exports=e,t.exports.__esModule=!0,t.exports.default=t.exports},1655:function(t,e,n){var r=n(6015);t.exports=function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),Object.defineProperty(t,"prototype",{writable:!1}),e&&r(t,e)},t.exports.__esModule=!0,t.exports.default=t.exports},9498:function(t){t.exports=function(t){if("undefined"!=typeof Symbol&&null!=t[Symbol.iterator]||null!=t["@@iterator"])return Array.from(t)},t.exports.__esModule=!0,t.exports.default=t.exports},2218:function(t){t.exports=function(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")},t.exports.__esModule=!0,t.exports.default=t.exports},4993:function(t,e,n){var r=n(8698).default,o=n(6115);t.exports=function(t,e){if(e&&("object"===r(e)||"function"==typeof e))return e;if(void 0!==e)throw new TypeError("Derived constructors may only return object or undefined");return o(t)},t.exports.__esModule=!0,t.exports.default=t.exports},6015:function(t){function e(n,r){return t.exports=e=Object.setPrototypeOf?Object.setPrototypeOf.bind():function(t,e){return t.__proto__=e,t},t.exports.__esModule=!0,t.exports.default=t.exports,e(n,r)}t.exports=e,t.exports.__esModule=!0,t.exports.default=t.exports},1589:function(t,e,n){var r=n(5372),o=n(9498),i=n(6116),a=n(2218);t.exports=function(t){return r(t)||o(t)||i(t)||a()},t.exports.__esModule=!0,t.exports.default=t.exports},5036:function(t,e,n){var r=n(8698).default;t.exports=function(t,e){if("object"!==r(t)||null===t)return t;var n=t[Symbol.toPrimitive];if(void 0!==n){var o=n.call(t,e||"default");if("object"!==r(o))return o;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===e?String:Number)(t)},t.exports.__esModule=!0,t.exports.default=t.exports},4062:function(t,e,n){var r=n(8698).default,o=n(5036);t.exports=function(t){var e=o(t,"string");return"symbol"===r(e)?e:String(e)},t.exports.__esModule=!0,t.exports.default=t.exports},8698:function(t){function e(n){return t.exports=e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},t.exports.__esModule=!0,t.exports.default=t.exports,e(n)}t.exports=e,t.exports.__esModule=!0,t.exports.default=t.exports},6116:function(t,e,n){var r=n(3897);t.exports=function(t,e){if(t){if("string"==typeof t)return r(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);return"Object"===n&&t.constructor&&(n=t.constructor.name),"Map"===n||"Set"===n?Array.from(t):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?r(t,e):void 0}},t.exports.__esModule=!0,t.exports.default=t.exports},9583:function(t){"use strict";t.exports=JSON.parse('{"origin-hint":{"seed":"Seed {{position}}","winner-bracket":"Loser of $t(abbreviations.winner-bracket) {{round}}.{{position}}","winner-bracket-semi-final":"Loser of $t(abbreviations.winner-bracket) Semi {{position}}","winner-bracket-final":"Loser of $t(abbreviations.winner-bracket) Final","consolation-final":"Loser of Semi {{position}}","grand-final":"Winner of $t(abbreviations.loser-bracket) Final","double-elimination-consolation-final-opponent-1":"Loser of $t(abbreviations.loser-bracket) Semi 1","double-elimination-consolation-final-opponent-2":"Loser of $t(abbreviations.loser-bracket) Final"},"match-label":{"default":"Match {{matchNumber}}","winner-bracket":"$t(abbreviations.winner-bracket)","loser-bracket":"$t(abbreviations.loser-bracket)","standard-bracket":"$t(abbreviations.match)","standard-bracket-semi-final":"Semi {{matchNumber}}","standard-bracket-final":"Final","double-elimination":"{{matchPrefix}} {{roundNumber}}.{{matchNumber}}","double-elimination-semi-final":"{{matchPrefix}} Semi {{matchNumber}}","double-elimination-final":"{{matchPrefix}} Final","consolation-final":"Consolation Final","grand-final-single":"Grand Final","grand-final":"$t(abbreviations.grand-final) Round {{roundNumber}}","match-game":"Game {{gameNumber}}"},"match-status":{"locked":"Locked","waiting":"Waiting","ready":"Ready","running":"Running","completed":"Completed","archived":"Archived"},"abbreviations":{"win":"W","loss":"L","forfeit":"F","position":"P","seed":"#","winner-bracket":"WB","loser-bracket":"LB","match":"M","grand-final":"GF"},"ranking":{"rank":{"text":"#","tooltip":"Rank"},"id":{"text":"Name","tooltip":"Name"},"played":{"text":"P","tooltip":"Played"},"wins":{"text":"$t(abbreviations.win)","tooltip":"Wins"},"draws":{"text":"D","tooltip":"Draws"},"losses":{"text":"$t(abbreviations.loss)","tooltip":"Losses"},"forfeits":{"text":"$t(abbreviations.forfeit)","tooltip":"Forfeits"},"scoreFor":{"text":"SF","tooltip":"Score For"},"scoreAgainst":{"text":"SA","tooltip":"Score Against"},"scoreDifference":{"text":"+/-","tooltip":"Score Difference"},"points":{"text":"Pts","tooltip":"Points"}},"common":{"bye":"BYE","best-of-x":"Bo{{x}}","consolation":"Consolation","group-name":"Group {{groupNumber}}","group-name-winner-bracket":"Winner Bracket","group-name-loser-bracket":"Loser Bracket","round-name":"Round {{roundNumber}}","round-name-final":"Final Round","round-name-winner-bracket":"$t(abbreviations.winner-bracket) Round {{roundNumber}}","round-name-winner-bracket-final":"$t(abbreviations.winner-bracket) Final Round","round-name-loser-bracket":"$t(abbreviations.loser-bracket) Round {{roundNumber}}","round-name-loser-bracket-final":"$t(abbreviations.loser-bracket) Final Round"},"form-creator":{"stage-name-label":"Name your stage","stage-name-placeholder":"Give a name for your stage","stage-selector-label":"Select a stage","team-label":"Name your teams","team-label-placeholder":"Comma separated List of Team Names (must be 2^n)","team-count":"Or a team count","team-count-placeholder":"How many teams do you want?","group-label":"How many groups?","group-placeholder":"How many groups do you want?","seed-order-label":"How would you like to order your seeds?","double-elimination-seed-order-placeholder":"Seed order for double elimination comma separated","round-robin-mode-label":"Which round robin mode do you like?","consolation-final-label":"Consolation Final","skip-first-round-label":"Skip first round","grand-final-type-label":"Grand final type","submit":"Create"}}')},8159:function(t){"use strict";t.exports=JSON.parse('{"origin-hint":{"seed":"Seed {{position}}","winner-bracket":"Perdant $t(abbreviations.winner-bracket) {{round}}.{{position}}","winner-bracket-semi-final":"Perdant $t(abbreviations.winner-bracket) Semi {{position}}","winner-bracket-final":"Perdant Finale $t(abbreviations.winner-bracket)","consolation-final":"Perdant Semi {{position}}","grand-final":"Gagnant Finale $t(abbreviations.loser-bracket)","double-elimination-consolation-final-opponent-1":"Perdant $t(abbreviations.loser-bracket) Semi 1","double-elimination-consolation-final-opponent-2":"Perdant $t(abbreviations.loser-bracket) Final"},"match-label":{"default":"Match {{matchNumber}}","winner-bracket":"$t(abbreviations.winner-bracket)","loser-bracket":"$t(abbreviations.loser-bracket)","standard-bracket":"$t(abbreviations.match)","standard-bracket-semi-final":"Semi {{matchNumber}}","standard-bracket-final":"Finale","double-elimination":"{{matchPrefix}} {{roundNumber}}.{{matchNumber}}","double-elimination-semi-final":"{{matchPrefix}} Semi {{matchNumber}}","double-elimination-final":"Finale {{matchPrefix}}","consolation-final":"Petite finale","grand-final-single":"Grande finale","grand-final":"$t(abbreviations.grand-final) Round {{roundNumber}}","match-game":"Game {{gameNumber}}"},"match-status":{"locked":"Verrouillé","waiting":"En attente","ready":"Prêt","running":"En cours","completed":"Terminé","archived":"Archivé"},"abbreviations":{"win":"V","loss":"D","forfeit":"F","position":"P","seed":"#","winner-bracket":"WB","loser-bracket":"LB","match":"M","grand-final":"GF"},"ranking":{"rank":{"text":"#","tooltip":"Rang"},"id":{"text":"Name","tooltip":"Nom"},"played":{"text":"J","tooltip":"Joué"},"wins":{"text":"$t(abbreviations.win)","tooltip":"Victoires"},"draws":{"text":"N","tooltip":"Match nul"},"losses":{"text":"$t(abbreviations.loss)","tooltip":"Défaites"},"forfeits":{"text":"$t(abbreviations.forfeit)","tooltip":"Forfaits"},"scoreFor":{"text":"SF","tooltip":"Score pour"},"scoreAgainst":{"text":"SA","tooltip":"Score contre"},"scoreDifference":{"text":"+/-","tooltip":"Différence de score"},"points":{"text":"Pts","tooltip":"Points"}},"common":{"bye":"BYE","best-of-x":"Bo{{x}}","consolation":"Consolation","group-name":"Groupe {{groupNumber}}","group-name-winner-bracket":"Winner Bracket","group-name-loser-bracket":"Loser Bracket","round-name":"Round {{roundNumber}}","round-name-final":"Round final","round-name-winner-bracket":"$t(abbreviations.winner-bracket) Round {{roundNumber}}","round-name-winner-bracket-final":"$t(abbreviations.winner-bracket) Round final","round-name-loser-bracket":"$t(abbreviations.loser-bracket) Round {{roundNumber}}","round-name-loser-bracket-final":"$t(abbreviations.loser-bracket) Round final"},"form-creator":{"stage-name-label":"Name your stage","stage-name-placeholder":"Give a name for your stage","stage-selector-label":"Select a stage","team-label":"Name your teams","team-placeholder":"Comma separated List of Team Names (must be 2^n)","team-count":"Or a team count","team-count-placeholder":"How many teams do you want?","group-label":"How many groups?","group-placeholder":"How many groups do you want?","seed-order-label":"How would you like to order your seeds?","double-elimination-seed-order-placeholder":"Seed order for double elimination comma separated","round-robin-mode-label":"Which round robin mode do you like?","consolation-final-label":"Consolation Final","skip-first-round-label":"Skip first round","grand-final-type-label":"Grand final type","submit":"Create"}}')}},e={};function n(r){var o=e[r];if(void 0!==o)return o.exports;var i=e[r]={exports:{}};return t[r].call(i.exports,i,i.exports,n),i.exports}n.r=function(t){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},n(9820)}();

+304

tournament.go

···

       1
       1
       +
       package main

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       	"log"

     

       6
       6
       +
       	"math"

     

       7
       7
       +
       	"sort"

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       // seedSubmissions sorts submissions by average moves (better performance = lower seed number)

     

       11
       11
       +
       func seedSubmissions(submissions []Submission) []Submission {

     

       12
       12
       +
       	// Calculate historical average moves for each submission

     

       13
       13
       +
       	type seedEntry struct {

     

       14
       14
       +
       		submission Submission

     

       15
       15
       +
       		avgMoves   float64

     

       16
       16
       +
       	}

     

       17
       17
       +
       	

     

       18
       18
       +
       	var entries []seedEntry

     

       19
       19
       +
       	for _, sub := range submissions {

     

       20
       20
       +
       		// Get historical performance

     

       21
       21
       +
       		var avgMoves float64

     

       22
       22
       +
       		err := globalDB.QueryRow(`

     

       23
       23
       +
       			SELECT AVG(CASE 

     

       24
       24
       +
       				WHEN m.player1_id = ? THEN m.player1_moves 

     

       25
       25
       +
       				ELSE m.player2_moves 

     

       26
       26
       +
       			END)

     

       27
       27
       +
       			FROM matches m

     

       28
       28
       +
       			WHERE m.player1_id = ? OR m.player2_id = ?

     

       29
       29
       +
       		`, sub.ID, sub.ID, sub.ID).Scan(&avgMoves)

     

       30
       30
       +
       		

     

       31
       31
       +
       		if err != nil || avgMoves == 0 {

     

       32
       32
       +
       			// No history, use worst seed (100 moves)

     

       33
       33
       +
       			avgMoves = 100

     

       34
       34
       +
       		}

     

       35
       35
       +
       		

     

       36
       36
       +
       		entries = append(entries, seedEntry{sub, avgMoves})

     

       37
       37
       +
       	}

     

       38
       38
       +
       	

     

       39
       39
       +
       	// Sort by avgMoves (lower is better)

     

       40
       40
       +
       	sort.Slice(entries, func(i, j int) bool {

     

       41
       41
       +
       		return entries[i].avgMoves < entries[j].avgMoves

     

       42
       42
       +
       	})

     

       43
       43
       +
       	

     

       44
       44
       +
       	var seeded []Submission

     

       45
       45
       +
       	for _, entry := range entries {

     

       46
       46
       +
       		seeded = append(seeded, entry.submission)

     

       47
       47
       +
       	}

     

       48
       48
       +
       	

     

       49
       49
       +
       	return seeded

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       // createBracket generates bracket matches for round 1

     

       53
       53
       +
       func createBracket(tournament *Tournament) error {

     

       54
       54
       +
       	// Get all active submissions

     

       55
       55
       +
       	submissions, err := getActiveSubmissions()

     

       56
       56
       +
       	if err != nil {

     

       57
       57
       +
       		return err

     

       58
       58
       +
       	}

     

       59
       59
       +
       	

     

       60
       60
       +
       	if len(submissions) < 2 {

     

       61
       61
       +
       		return fmt.Errorf("need at least 2 players for tournament")

     

       62
       62
       +
       	}

     

       63
       63
       +
       	

     

       64
       64
       +
       	// Seed players

     

       65
       65
       +
       	seeded := seedSubmissions(submissions)

     

       66
       66
       +
       	

     

       67
       67
       +
       	log.Printf("Tournament %d: Seeded %d players", tournament.ID, len(seeded))

     

       68
       68
       +
       	for i, sub := range seeded {

     

       69
       69
       +
       		log.Printf("  Seed %d: %s", i+1, sub.Username)

     

       70
       70
       +
       	}

     

       71
       71
       +
       	

     

       72
       72
       +
       	// Find next power of 2

     

       73
       73
       +
       	numPlayers := len(seeded)

     

       74
       74
       +
       	bracketSize := int(math.Pow(2, math.Ceil(math.Log2(float64(numPlayers)))))

     

       75
       75
       +
       	

     

       76
       76
       +
       	log.Printf("Tournament %d: Bracket size=%d, players=%d", 

     

       77
       77
       +
       		tournament.ID, bracketSize, numPlayers)

     

       78
       78
       +
       	

     

       79
       79
       +
       	// Create round 1 matches using standard bracket seeding

     

       80
       80
       +
       	// Seed 1 vs Seed 16, Seed 2 vs Seed 15, etc.

     

       81
       81
       +
       	// For non-power-of-2, higher seeds get byes

     

       82
       82
       +
       	

     

       83
       83
       +
       	numFirstRoundMatches := bracketSize / 2

     

       84
       84
       +
       	

     

       85
       85
       +
       	for matchPos := 0; matchPos < numFirstRoundMatches; matchPos++ {

     

       86
       86
       +
       		// Standard bracket pairing: top seed vs bottom seed

     

       87
       87
       +
       		topSeedIdx := matchPos

     

       88
       88
       +
       		bottomSeedIdx := numPlayers - 1 - matchPos

     

       89
       89
       +
       		

     

       90
       90
       +
       		// Stop if we've paired all players (indices would overlap)

     

       91
       91
       +
       		if topSeedIdx >= bottomSeedIdx && topSeedIdx < numPlayers && bottomSeedIdx >= 0 {

     

       92
       92
       +
       			// Only one player left unpaired - give them a bye

     

       93
       93
       +
       			if topSeedIdx == bottomSeedIdx {

     

       94
       94
       +
       				player1ID := seeded[topSeedIdx].ID

     

       95
       95
       +
       				player1Name := seeded[topSeedIdx].Username

     

       96
       96
       +
       				

     

       97
       97
       +
       				err = addBracketMatch(tournament.ID, 1, matchPos, player1ID, 0)

     

       98
       98
       +
       				if err != nil {

     

       99
       99
       +
       					return err

     

       100
       100
       +
       				}

     

       101
       101
       +
       				

     

       102
       102
       +
       				globalDB.Exec(`

     

       103
       103
       +
       					UPDATE bracket_matches 

     

       104
       104
       +
       					SET winner_id = ?, status = 'completed', 

     

       105
       105
       +
       					    player1_wins = 0, player2_wins = 0,

     

       106
       106
       +
       					    player1_moves = 0, player2_moves = 0

     

       107
       107
       +
       					WHERE tournament_id = ? AND round = 1 AND position = ?

     

       108
       108
       +
       				`, player1ID, tournament.ID, matchPos)

     

       109
       109
       +
       				

     

       110
       110
       +
       				log.Printf("  Match %d: %s vs BYE (auto-advance)", matchPos, player1Name)

     

       111
       111
       +
       			}

     

       112
       112
       +
       			break

     

       113
       113
       +
       		}

     

       114
       114
       +
       		

     

       115
       115
       +
       		var player1ID, player2ID int

     

       116
       116
       +
       		var player1Name, player2Name string

     

       117
       117
       +
       		

     

       118
       118
       +
       		// Check if top seed exists

     

       119
       119
       +
       		if topSeedIdx < numPlayers {

     

       120
       120
       +
       			player1ID = seeded[topSeedIdx].ID

     

       121
       121
       +
       			player1Name = seeded[topSeedIdx].Username

     

       122
       122
       +
       		} else {

     

       123
       123
       +
       			player1ID = 0

     

       124
       124
       +
       			player1Name = "BYE"

     

       125
       125
       +
       		}

     

       126
       126
       +
       		

     

       127
       127
       +
       		// Check if bottom seed exists

     

       128
       128
       +
       		if bottomSeedIdx >= 0 && bottomSeedIdx < numPlayers {

     

       129
       129
       +
       			player2ID = seeded[bottomSeedIdx].ID

     

       130
       130
       +
       			player2Name = seeded[bottomSeedIdx].Username

     

       131
       131
       +
       		} else {

     

       132
       132
       +
       			player2ID = 0

     

       133
       133
       +
       			player2Name = "BYE"

     

       134
       134
       +
       		}

     

       135
       135
       +
       		

     

       136
       136
       +
       		// Skip if both are byes

     

       137
       137
       +
       		if player1ID == 0 && player2ID == 0 {

     

       138
       138
       +
       			continue

     

       139
       139
       +
       		}

     

       140
       140
       +
       		

     

       141
       141
       +
       		// Create match

     

       142
       142
       +
       		err = addBracketMatch(tournament.ID, 1, matchPos, player1ID, player2ID)

     

       143
       143
       +
       		if err != nil {

     

       144
       144
       +
       			return err

     

       145
       145
       +
       		}

     

       146
       146
       +
       		

     

       147
       147
       +
       		// If one is a bye, auto-complete

     

       148
       148
       +
       		if player1ID == 0 || player2ID == 0 {

     

       149
       149
       +
       			winnerID := player1ID

     

       150
       150
       +
       			if player1ID == 0 {

     

       151
       151
       +
       				winnerID = player2ID

     

       152
       152
       +
       			}

     

       153
       153
       +
       			

     

       154
       154
       +
       			globalDB.Exec(`

     

       155
       155
       +
       				UPDATE bracket_matches 

     

       156
       156
       +
       				SET winner_id = ?, status = 'completed', 

     

       157
       157
       +
       				    player1_wins = 0, player2_wins = 0,

     

       158
       158
       +
       				    player1_moves = 0, player2_moves = 0

     

       159
       159
       +
       				WHERE tournament_id = ? AND round = 1 AND position = ?

     

       160
       160
       +
       			`, winnerID, tournament.ID, matchPos)

     

       161
       161
       +
       			

     

       162
       162
       +
       			log.Printf("  Match %d: %s vs %s (BYE - winner: %s)", 

     

       163
       163
       +
       				matchPos, player1Name, player2Name, 

     

       164
       164
       +
       				map[bool]string{true: player1Name, false: player2Name}[player1ID == winnerID])

     

       165
       165
       +
       		} else {

     

       166
       166
       +
       			log.Printf("  Match %d: %s (seed %d) vs %s (seed %d)", 

     

       167
       167
       +
       				matchPos, player1Name, topSeedIdx+1, player2Name, bottomSeedIdx+1)

     

       168
       168
       +
       		}

     

       169
       169
       +
       	}

     

       170
       170
       +
       	

     

       171
       171
       +
       	return nil

     

       172
       172
       +
       }

     

       173
       173
       +
       

     

       174
       174
       +
       // advanceWinners creates next round matches from current round winners

     

       175
       175
       +
       func advanceWinners(tournamentID, currentRound int) error {

     

       176
       176
       +
       	// Get completed matches from current round

     

       177
       177
       +
       	query := `

     

       178
       178
       +
       		SELECT id, position, winner_id 

     

       179
       179
       +
       		FROM bracket_matches 

     

       180
       180
       +
       		WHERE tournament_id = ? AND round = ? AND status = 'completed'

     

       181
       181
       +
       		ORDER BY position

     

       182
       182
       +
       	`

     

       183
       183
       +
       	

     

       184
       184
       +
       	rows, err := globalDB.Query(query, tournamentID, currentRound)

     

       185
       185
       +
       	if err != nil {

     

       186
       186
       +
       		return err

     

       187
       187
       +
       	}

     

       188
       188
       +
       	defer rows.Close()

     

       189
       189
       +
       	

     

       190
       190
       +
       	var winners []struct {

     

       191
       191
       +
       		matchID  int

     

       192
       192
       +
       		position int

     

       193
       193
       +
       		winnerID int

     

       194
       194
       +
       	}

     

       195
       195
       +
       	

     

       196
       196
       +
       	for rows.Next() {

     

       197
       197
       +
       		var w struct {

     

       198
       198
       +
       			matchID  int

     

       199
       199
       +
       			position int

     

       200
       200
       +
       			winnerID int

     

       201
       201
       +
       		}

     

       202
       202
       +
       		rows.Scan(&w.matchID, &w.position, &w.winnerID)

     

       203
       203
       +
       		winners = append(winners, w)

     

       204
       204
       +
       	}

     

       205
       205
       +
       	

     

       206
       206
       +
       	if len(winners) == 1 {

     

       207
       207
       +
       		// Tournament complete!

     

       208
       208
       +
       		log.Printf("Tournament %d complete! Winner: ID %d", tournamentID, winners[0].winnerID)

     

       209
       209
       +
       		return completeTournament(tournamentID, winners[0].winnerID)

     

       210
       210
       +
       	}

     

       211
       211
       +
       	

     

       212
       212
       +
       	// Create matches for next round

     

       213
       213
       +
       	nextRound := currentRound + 1

     

       214
       214
       +
       	log.Printf("Advancing to round %d with %d winners", nextRound, len(winners))

     

       215
       215
       +
       	

     

       216
       216
       +
       	for i := 0; i < len(winners); i += 2 {

     

       217
       217
       +
       		if i+1 >= len(winners) {

     

       218
       218
       +
       			// Odd number of winners, give bye

     

       219
       219
       +
       			log.Printf("  Round %d Match %d: BYE (winner: ID %d)", nextRound, i/2, winners[i].winnerID)

     

       220
       220
       +
       			err = addBracketMatch(tournamentID, nextRound, i/2, winners[i].winnerID, 0)

     

       221
       221
       +
       			if err != nil {

     

       222
       222
       +
       				return err

     

       223
       223
       +
       			}

     

       224
       224
       +
       			// Auto-complete bye

     

       225
       225
       +
       			globalDB.Exec(`

     

       226
       226
       +
       				UPDATE bracket_matches 

     

       227
       227
       +
       				SET winner_id = ?, status = 'completed',

     

       228
       228
       +
       				    player1_wins = 0, player2_wins = 0,

     

       229
       229
       +
       				    player1_moves = 0, player2_moves = 0

     

       230
       230
       +
       				WHERE tournament_id = ? AND round = ? AND position = ?

     

       231
       231
       +
       			`, winners[i].winnerID, tournamentID, nextRound, i/2)

     

       232
       232
       +
       		} else {

     

       233
       233
       +
       			log.Printf("  Round %d Match %d: ID %d vs ID %d", nextRound, i/2, winners[i].winnerID, winners[i+1].winnerID)

     

       234
       234
       +
       			err = addBracketMatch(tournamentID, nextRound, i/2, winners[i].winnerID, winners[i+1].winnerID)

     

       235
       235
       +
       			if err != nil {

     

       236
       236
       +
       				return err

     

       237
       237
       +
       			}

     

       238
       238
       +
       		}

     

       239
       239
       +
       	}

     

       240
       240
       +
       	

     

       241
       241
       +
       	// Update tournament round

     

       242
       242
       +
       	return updateTournamentRound(tournamentID, nextRound)

     

       243
       243
       +
       }

     

       244
       244
       +
       

     

       245
       245
       +
       // ensureTournamentExists creates a tournament if none exists AND there are new submissions

     

       246
       246
       +
       func ensureTournamentExists() (*Tournament, error) {

     

       247
       247
       +
       	tournament, err := getActiveTournament()

     

       248
       248
       +
       	if err != nil {

     

       249
       249
       +
       		return nil, err

     

       250
       250
       +
       	}

     

       251
       251
       +
       	

     

       252
       252
       +
       	if tournament != nil {

     

       253
       253
       +
       		// Active tournament exists

     

       254
       254
       +
       		return tournament, nil

     

       255
       255
       +
       	}

     

       256
       256
       +
       	

     

       257
       257
       +
       	// No active tournament - check if we should create one

     

       258
       258
       +
       	// Only create if there's been a new submission since last tournament

     

       259
       259
       +
       	latestTournament, err := getLatestTournament()

     

       260
       260
       +
       	if err != nil {

     

       261
       261
       +
       		return nil, err

     

       262
       262
       +
       	}

     

       263
       263
       +
       	

     

       264
       264
       +
       	submissions, err := getActiveSubmissions()

     

       265
       265
       +
       	if err != nil {

     

       266
       266
       +
       		return nil, err

     

       267
       267
       +
       	}

     

       268
       268
       +
       	

     

       269
       269
       +
       	if len(submissions) < 2 {

     

       270
       270
       +
       		log.Printf("Not enough players for tournament (%d/2), waiting...", len(submissions))

     

       271
       271
       +
       		return nil, fmt.Errorf("need at least 2 players")

     

       272
       272
       +
       	}

     

       273
       273
       +
       	

     

       274
       274
       +
       	// Check if any submission is newer than the last tournament

     

       275
       275
       +
       	if latestTournament != nil {

     

       276
       276
       +
       		hasNewSubmission := false

     

       277
       277
       +
       		for _, sub := range submissions {

     

       278
       278
       +
       			if sub.UploadTime.After(latestTournament.CreatedAt) {

     

       279
       279
       +
       				hasNewSubmission = true

     

       280
       280
       +
       				break

     

       281
       281
       +
       			}

     

       282
       282
       +
       		}

     

       283
       283
       +
       		

     

       284
       284
       +
       		if !hasNewSubmission {

     

       285
       285
       +
       			log.Printf("No new submissions since last tournament, not creating new tournament")

     

       286
       286
       +
       			return nil, fmt.Errorf("no new submissions")

     

       287
       287
       +
       		}

     

       288
       288
       +
       	}

     

       289
       289
       +
       	

     

       290
       290
       +
       	log.Printf("Creating tournament with %d players...", len(submissions))

     

       291
       291
       +
       	tournament, err = createTournament()

     

       292
       292
       +
       	if err != nil {

     

       293
       293
       +
       		return nil, err

     

       294
       294
       +
       	}

     

       295
       295
       +
       	

     

       296
       296
       +
       	// Generate bracket

     

       297
       297
       +
       	err = createBracket(tournament)

     

       298
       298
       +
       	if err != nil {

     

       299
       299
       +
       		return nil, err

     

       300
       300
       +
       	}

     

       301
       301
       +
       	log.Printf("Created tournament %d with bracket", tournament.ID)

     

       302
       302
       +
       	

     

       303
       303
       +
       	return tournament, nil

     

       304
       304
       +
       }

+156 -49

web.go

···

       14
       14
        
           <title>Battleship Arena - Leaderboard</title>

     

       15
       15
        
           <meta charset="UTF-8">

     

       16
       16
        
           <meta name="viewport" content="width=device-width, initial-scale=1.0">

     

       17
       17
       -
           <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/brackets-viewer@latest/dist/brackets-viewer.min.css" />

     

       17
       17
       +
           <link rel="stylesheet" href="/static/brackets-viewer.min.css" />

     

       18
       18
        
           <style>

     

       19
       19
        
               body {

     

       20
       20
        
                   font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', sans-serif;

     
···

       74
       74
        
               .win-rate-high { color: #10b981; }

     

       75
       75
        
               .win-rate-med { color: #f59e0b; }

     

       76
       76
        
               .win-rate-low { color: #ef4444; }

     

       77
       77
       +
               .stage {

     

       78
       78
       +
                   display: inline-block;

     

       79
       79
       +
                   padding: 4px 12px;

     

       80
       80
       +
                   border-radius: 12px;

     

       81
       81
       +
                   font-size: 0.85em;

     

       82
       82
       +
                   font-weight: 600;

     

       83
       83
       +
               }

     

       84
       84
       +
               .stage-Expert {

     

       85
       85
       +
                   background: #10b981;

     

       86
       86
       +
                   color: white;

     

       87
       87
       +
               }

     

       88
       88
       +
               .stage-Advanced {

     

       89
       89
       +
                   background: #3b82f6;

     

       90
       90
       +
                   color: white;

     

       91
       91
       +
               }

     

       92
       92
       +
               .stage-Intermediate {

     

       93
       93
       +
                   background: #f59e0b;

     

       94
       94
       +
                   color: white;

     

       95
       95
       +
               }

     

       96
       96
       +
               .stage-Beginner {

     

       97
       97
       +
                   background: #6b7280;

     

       98
       98
       +
                   color: white;

     

       99
       99
       +
               }

     

       77
       100
        
               .stats {

     

       78
       101
        
                   display: flex;

     

       79
       102
        
                   justify-content: space-around;

     
···

       127
       150
        
                   margin-bottom: 30px;

     

       128
       151
        
               }

     

       129
       152
        
           </style>

     

       130
       130
       -
           <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/brackets-viewer@latest/dist/brackets-viewer.min.js"></script>

     

       153
       153
       +
           <script type="text/javascript" src="/static/brackets-viewer.min.js"></script>

     

       131
       154
        
           <script>

     

       132
       155
        
               // Auto-refresh every 30 seconds

     

       133
       156
        
               setTimeout(() => location.reload(), 30000);

     
···

       168
       191
        
                       <tr>

     

       169
       192
        
                           <th>Rank</th>

     

       170
       193
        
                           <th>Player</th>

     

       194
       194
       +
                           <th>Stage</th>

     

       171
       195
        
                           <th>Wins</th>

     

       172
       196
        
                           <th>Losses</th>

     

       173
       197
        
                           <th>Win Rate</th>

     
···

       181
       205
        
                       <tr>

     

       182
       206
        
                           <td class="rank rank-{{add $i 1}}">{{if lt $i 3}}{{medal $i}}{{else}}#{{add $i 1}}{{end}}</td>

     

       183
       207
        
                           <td><strong>{{$e.Username}}</strong></td>

     

       208
       208
       +
                           <td><span class="stage stage-{{$e.Stage}}">{{$e.Stage}}</span></td>

     

       184
       209
        
                           <td>{{$e.Wins}}</td>

     

       185
       210
        
                           <td>{{$e.Losses}}</td>

     

       186
       211
        
                           <td class="win-rate {{winRateClass $e}}">{{winRate $e}}%</td>

     
···

       190
       215
        
                       {{end}}

     

       191
       216
        
                       {{else}}

     

       192
       217
        
                       <tr>

     

       193
       193
       -
                           <td colspan="7" style="text-align: center; padding: 40px; color: #999;">

     

       218
       218
       +
                           <td colspan="8" style="text-align: center; padding: 40px; color: #999;">

     

       194
       219
        
                               No submissions yet. Be the first to compete!

     

       195
       220
        
                           </td>

     

       196
       221
        
                       </tr>

     
···

       312
       337
        
       }

     

       313
       338
        
       

     

       314
       339
        
       func handleBracketData(w http.ResponseWriter, r *http.Request) {

     

       315
       315
       -
       	matches, err := getAllMatches()

     

       340
       340
       +
       	// Get latest tournament (active or completed)

     

       341
       341
       +
       	tournament, err := getLatestTournament()

     

       342
       342
       +
       	if err != nil {

     

       343
       343
       +
       		http.Error(w, fmt.Sprintf("Failed to load tournament: %v", err), http.StatusInternalServerError)

     

       344
       344
       +
       		return

     

       345
       345
       +
       	}

     

       346
       346
       +
       	

     

       347
       347
       +
       	if tournament == nil {

     

       348
       348
       +
       		// No tournament yet

     

       349
       349
       +
       		w.Header().Set("Content-Type", "application/json")

     

       350
       350
       +
       		json.NewEncoder(w).Encode(map[string]interface{}{

     

       351
       351
       +
       			"stages":       []map[string]interface{}{},

     

       352
       352
       +
       			"matches":      []map[string]interface{}{},

     

       353
       353
       +
       			"participants": []map[string]interface{}{},

     

       354
       354
       +
       		})

     

       355
       355
       +
       		return

     

       356
       356
       +
       	}

     

       357
       357
       +
       	

     

       358
       358
       +
       	// Get all bracket matches

     

       359
       359
       +
       	matches, err := getAllBracketMatches(tournament.ID)

     

       316
       360
        
       	if err != nil {

     

       317
       361
        
       		http.Error(w, fmt.Sprintf("Failed to load matches: %v", err), http.StatusInternalServerError)

     

       318
       362
        
       		return

     

       319
       363
        
       	}

     

       320
       364
        
       

     

       321
       365
        
       	if matches == nil {

     

       322
       322
       -
       		matches = []MatchResult{}

     

       366
       366
       +
       		matches = []BracketMatch{}

     

       323
       367
        
       	}

     

       324
       368
        
       

     

       325
       325
       -
       	// Get unique participants

     

       326
       326
       -
       	participantMap := make(map[string]int)

     

       369
       369
       +
       	// Get unique participants (skip byes where ID = 0)

     

       370
       370
       +
       	participantMap := make(map[int]int) // submissionID -> participantID

     

       327
       371
        
       	participants := []map[string]interface{}{}

     

       328
       372
        
       	participantID := 1

     

       329
       373
        
       

     

       330
       374
        
       	for _, match := range matches {

     

       331
       331
       -
       		if _, exists := participantMap[match.Player1Username]; !exists {

     

       332
       332
       -
       			participantMap[match.Player1Username] = participantID

     

       333
       333
       -
       			participants = append(participants, map[string]interface{}{

     

       334
       334
       -
       				"id":   participantID,

     

       335
       335
       -
       				"name": match.Player1Username,

     

       336
       336
       -
       			})

     

       337
       337
       -
       			participantID++

     

       375
       375
       +
       		if match.Player1ID > 0 && match.Player1Name != "" {

     

       376
       376
       +
       			if _, exists := participantMap[match.Player1ID]; !exists {

     

       377
       377
       +
       				participantMap[match.Player1ID] = participantID

     

       378
       378
       +
       				participants = append(participants, map[string]interface{}{

     

       379
       379
       +
       					"id":   participantID,

     

       380
       380
       +
       					"name": match.Player1Name,

     

       381
       381
       +
       				})

     

       382
       382
       +
       				participantID++

     

       383
       383
       +
       			}

     

       384
       384
       +
       		}

     

       385
       385
       +
       		if match.Player2ID > 0 && match.Player2Name != "" {

     

       386
       386
       +
       			if _, exists := participantMap[match.Player2ID]; !exists {

     

       387
       387
       +
       				participantMap[match.Player2ID] = participantID

     

       388
       388
       +
       				participants = append(participants, map[string]interface{}{

     

       389
       389
       +
       					"id":   participantID,

     

       390
       390
       +
       					"name": match.Player2Name,

     

       391
       391
       +
       				})

     

       392
       392
       +
       				participantID++

     

       393
       393
       +
       			}

     

       338
       394
        
       		}

     

       339
       339
       -
       		if _, exists := participantMap[match.Player2Username]; !exists {

     

       340
       340
       -
       			participantMap[match.Player2Username] = participantID

     

       341
       341
       -
       			participants = append(participants, map[string]interface{}{

     

       342
       342
       -
       				"id":   participantID,

     

       343
       343
       -
       				"name": match.Player2Username,

     

       344
       344
       -
       			})

     

       345
       345
       -
       			participantID++

     

       395
       395
       +
       	}

     

       396
       396
       +
       

     

       397
       397
       +
       	// Group matches by round for bracket format

     

       398
       398
       +
       	roundMatches := make(map[int][]BracketMatch)

     

       399
       399
       +
       	maxRound := 0

     

       400
       400
       +
       	for _, match := range matches {

     

       401
       401
       +
       		roundMatches[match.Round] = append(roundMatches[match.Round], match)

     

       402
       402
       +
       		if match.Round > maxRound {

     

       403
       403
       +
       			maxRound = match.Round

     

       346
       404
        
       		}

     

       347
       405
        
       	}

     

       348
       406
        
       

     

       349
       349
       -
       	// Create match data in brackets-viewer format

     

       407
       407
       +
       	// Create match data in brackets-viewer format (single elimination)

     

       350
       408
        
       	bracketMatches := []map[string]interface{}{}

     

       351
       351
       -
       	for i, match := range matches {

     

       352
       352
       -
       		opponent1 := map[string]interface{}{

     

       353
       353
       -
       			"id":     participantMap[match.Player1Username],

     

       354
       354
       -
       			"result": "loss",

     

       355
       355
       -
       		}

     

       356
       356
       -
       		opponent2 := map[string]interface{}{

     

       357
       357
       -
       			"id":     participantMap[match.Player2Username],

     

       358
       358
       -
       			"result": "loss",

     

       359
       359
       -
       		}

     

       409
       409
       +
       	matchNumber := 1

     

       410
       410
       +
       	

     

       411
       411
       +
       	for round := 1; round <= maxRound; round++ {

     

       412
       412
       +
       		for _, match := range roundMatches[round] {

     

       413
       413
       +
       			var opponent1, opponent2 map[string]interface{}

     

       414
       414
       +
       			

     

       415
       415
       +
       			// Player 1

     

       416
       416
       +
       			if match.Player1ID > 0 {

     

       417
       417
       +
       				result := "loss"

     

       418
       418
       +
       				if match.WinnerID == match.Player1ID {

     

       419
       419
       +
       					result = "win"

     

       420
       420
       +
       				}

     

       421
       421
       +
       				opponent1 = map[string]interface{}{

     

       422
       422
       +
       					"id":     participantMap[match.Player1ID],

     

       423
       423
       +
       					"result": result,

     

       424
       424
       +
       					"score":  match.Player1Wins,

     

       425
       425
       +
       				}

     

       426
       426
       +
       			} else {

     

       427
       427
       +
       				opponent1 = nil // Bye

     

       428
       428
       +
       			}

     

       429
       429
       +
       			

     

       430
       430
       +
       			// Player 2

     

       431
       431
       +
       			if match.Player2ID > 0 {

     

       432
       432
       +
       				result := "loss"

     

       433
       433
       +
       				if match.WinnerID == match.Player2ID {

     

       434
       434
       +
       					result = "win"

     

       435
       435
       +
       				}

     

       436
       436
       +
       				opponent2 = map[string]interface{}{

     

       437
       437
       +
       					"id":     participantMap[match.Player2ID],

     

       438
       438
       +
       					"result": result,

     

       439
       439
       +
       					"score":  match.Player2Wins,

     

       440
       440
       +
       				}

     

       441
       441
       +
       			} else {

     

       442
       442
       +
       				opponent2 = nil // Bye

     

       443
       443
       +
       			}

     

       360
       444
        
       

     

       361
       361
       -
       		if match.WinnerUsername == match.Player1Username {

     

       362
       362
       -
       			opponent1["result"] = "win"

     

       363
       363
       -
       		} else {

     

       364
       364
       -
       			opponent2["result"] = "win"

     

       365
       365
       -
       		}

     

       445
       445
       +
       			status := "pending"

     

       446
       446
       +
       			if match.Status == "completed" {

     

       447
       447
       +
       				status = "completed"

     

       448
       448
       +
       			}

     

       366
       449
        
       

     

       367
       367
       -
       		bracketMatches = append(bracketMatches, map[string]interface{}{

     

       368
       368
       -
       			"id":         i + 1,

     

       369
       369
       -
       			"stage_id":   1,

     

       370
       370
       -
       			"group_id":   1,

     

       371
       371
       -
       			"round_id":   1,

     

       372
       372
       -
       			"number":     i + 1,

     

       373
       373
       -
       			"opponent1":  opponent1,

     

       374
       374
       -
       			"opponent2":  opponent2,

     

       375
       375
       -
       			"status":     "completed",

     

       376
       376
       -
       		})

     

       450
       450
       +
       			bracketMatches = append(bracketMatches, map[string]interface{}{

     

       451
       451
       +
       				"id":         matchNumber,

     

       452
       452
       +
       				"stage_id":   1,

     

       453
       453
       +
       				"group_id":   1,

     

       454
       454
       +
       				"round_id":   round,

     

       455
       455
       +
       				"number":     match.Position + 1,

     

       456
       456
       +
       				"opponent1":  opponent1,

     

       457
       457
       +
       				"opponent2":  opponent2,

     

       458
       458
       +
       				"status":     status,

     

       459
       459
       +
       			})

     

       460
       460
       +
       			matchNumber++

     

       461
       461
       +
       		}

     

       377
       462
        
       	}

     

       378
       463
        
       

     

       379
       379
       -
       	// Create stage data

     

       464
       464
       +
       	// Create stage data for single elimination

     

       465
       465
       +
       	// Calculate bracket size (next power of 2)

     

       466
       466
       +
       	bracketSize := 1

     

       467
       467
       +
       	for bracketSize < len(participants) {

     

       468
       468
       +
       		bracketSize *= 2

     

       469
       469
       +
       	}

     

       470
       470
       +
       	

     

       380
       471
        
       	stages := []map[string]interface{}{

     

       381
       472
        
       		{

     

       382
       473
        
       			"id":     1,

     

       383
       383
       -
       			"name":   "Round Robin",

     

       384
       384
       -
       			"type":   "round_robin",

     

       474
       474
       +
       			"name":   "Tournament",

     

       475
       475
       +
       			"type":   "single_elimination",

     

       385
       476
        
       			"number": 1,

     

       477
       477
       +
       			"settings": map[string]interface{}{

     

       478
       478
       +
       				"size":           bracketSize,

     

       479
       479
       +
       				"seedOrdering":   []string{"natural"},

     

       480
       480
       +
       				"grandFinal":     "none",

     

       481
       481
       +
       				"skipFirstRound": false,

     

       482
       482
       +
       			},

     

       483
       483
       +
       		},

     

       484
       484
       +
       	}

     

       485
       485
       +
       	

     

       486
       486
       +
       	// Create groups array (required for brackets-viewer)

     

       487
       487
       +
       	groups := []map[string]interface{}{

     

       488
       488
       +
       		{

     

       489
       489
       +
       			"id":       1,

     

       490
       490
       +
       			"stage_id": 1,

     

       491
       491
       +
       			"number":   1,

     

       386
       492
        
       		},

     

       387
       493
        
       	}

     

       388
       494
        
       

     

       389
       495
        
       	data := map[string]interface{}{

     

       390
       496
        
       		"stages":       stages,

     

       497
       497
       +
       		"groups":       groups,

     

       391
       498
        
       		"matches":      bracketMatches,

     

       392
       499
        
       		"matchGames":   []map[string]interface{}{},

     

       393
       500
        
       		"participants": participants,

+9 -3

worker.go

···

       6
       6
        
       	"time"

     

       7
       7
        
       )

     

       8
       8
        
       

     

       9
       9
       -
       // Background worker that processes pending submissions

     

       9
       9
       +
       // Background worker that processes pending submissions and bracket matches

     

       10
       10
        
       func startWorker(ctx context.Context) {

     

       11
       11
        
       	ticker := time.NewTicker(10 * time.Second)

     

       12
       12
        
       	defer ticker.Stop()

     

       13
       13
        
       

     

       14
       14
        
       	// Process immediately on start

     

       15
       15
        
       	if err := processSubmissions(); err != nil {

     

       16
       16
       -
       		log.Printf("Worker error: %v", err)

     

       16
       16
       +
       		log.Printf("Worker error (submissions): %v", err)

     

       17
       17
       +
       	}

     

       18
       18
       +
       	if err := processBracketMatches(); err != nil {

     

       19
       19
       +
       		log.Printf("Worker error (bracket): %v", err)

     

       17
       20
        
       	}

     

       18
       21
        
       

     

       19
       22
        
       	for {

     
···

       22
       25
        
       			return

     

       23
       26
        
       		case <-ticker.C:

     

       24
       27
        
       			if err := processSubmissions(); err != nil {

     

       25
       25
       -
       				log.Printf("Worker error: %v", err)

     

       28
       28
       +
       				log.Printf("Worker error (submissions): %v", err)

     

       29
       29
       +
       			}

     

       30
       30
       +
       			if err := processBracketMatches(); err != nil {

     

       31
       31
       +
       				log.Printf("Worker error (bracket): %v", err)

     

       26
       32
        
       			}

     

       27
       33
        
       		}

     

       28
       34
        
       	}