scrabble-solver 2.18.10-alpha.0 → 2.18.10-alpha.2

package/packages/word-lists/build/languages/polish.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWordList = void 0;
+const types_1 = require("@scrabble-solver/types");
+const cheerio_1 = require("cheerio");
+const fs_1 = __importDefault(require("fs"));
+const url_1 = require("url");
+const lib_1 = require("../lib");
+const PAGE_URL = 'https://sjp.pl/sl/growy/';
+const FILE_TO_EXTRACT_FROM_ZIP = 'slowa.txt';
+const REASONABLE_VALID_WORD_COUNT_TRESHOLD = 2_000_000; // more like 3M, but just to be safe
+const SECONDARY_FILE_URL = 'https://raw.githubusercontent.com/kamilmielnik/scrabble-dictionaries/refs/heads/master/polish/sjp.txt';
+const getWordList = async () => {
+    try {
+        const tempFilepath = (0, lib_1.getTempFilepath)();
+        const zipUrl = await fetchZipUrl(PAGE_URL);
+        const zipTempFilename = await (0, lib_1.downloadFile)(zipUrl);
+        await (0, lib_1.unzip)(zipTempFilename, FILE_TO_EXTRACT_FROM_ZIP, tempFilepath);
+        fs_1.default.unlinkSync(zipTempFilename);
+        const file = fs_1.default.readFileSync(tempFilepath, 'utf-8');
+        fs_1.default.unlinkSync(tempFilepath);
+        const words = (0, lib_1.extractWords)(file.toLocaleString(), 'pl-PL');
+        if (words.length < REASONABLE_VALID_WORD_COUNT_TRESHOLD) {
+            return getBackupWordList();
+        }
+        return words;
+    }
+    catch {
+        return getBackupWordList();
+    }
+};
+exports.getWordList = getWordList;
+const fetchZipUrl = async (url) => {
+    const html = await (0, lib_1.downloadHtml)(url);
+    const filename = parseZipContainingPage(html);
+    const { href } = new url_1.URL(filename, url);
+    return href;
+};
+const parseZipContainingPage = (html) => {
+    const $ = (0, cheerio_1.load)(html);
+    const $links = $('a');
+    const links = Array.from($links)
+        .map((link) => $(link).attr('href'))
+        .filter(Boolean);
+    const zipFilename = links.find((link) => link.endsWith('.zip'));
+    if (typeof zipFilename === 'undefined') {
+        throw new Error('Cannot find link to zip file on the page');
+    }
+    return zipFilename;
+};
+const getBackupWordList = () => {
+    return (0, lib_1.getTxtWordList)(SECONDARY_FILE_URL, types_1.Locale.PL_PL);
+};

package/packages/word-lists/build/languages/romanian.d.ts

@@ -0,0 +1 @@
+export declare const getWordList: () => Promise<string[]>;

package/packages/word-lists/build/languages/romanian.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWordList = void 0;
+const types_1 = require("@scrabble-solver/types");
+const lib_1 = require("../lib");
+const FILE_URL = 'https://raw.githubusercontent.com/kamilmielnik/scrabble-dictionaries/master/romanian/loc-5.0.txt';
+const getWordList = async () => {
+    const words = await (0, lib_1.getTxtWordList)(FILE_URL, types_1.Locale.RO_RO);
+    return (0, lib_1.transliterateDiacritics)(words);
+};
+exports.getWordList = getWordList;

package/packages/word-lists/build/languages/spanish.d.ts

@@ -0,0 +1 @@
+export declare const getWordList: () => Promise<string[]>;

package/packages/word-lists/build/languages/spanish.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWordList = void 0;
+const types_1 = require("@scrabble-solver/types");
+const lib_1 = require("../lib");
+const FILE_URL = 'https://raw.githubusercontent.com/kamilmielnik/scrabble-dictionaries/master/spanish/file-2017.txt';
+const getWordList = async () => {
+    const words = await (0, lib_1.getTxtWordList)(FILE_URL, types_1.Locale.ES_ES);
+    return (0, lib_1.transliterateDiacritics)(words, { ignore: ['ñ'] });
+};
+exports.getWordList = getWordList;

package/packages/word-lists/build/languages/turkish.d.ts

@@ -0,0 +1 @@
+export declare const getWordList: () => Promise<string[]>;

package/packages/word-lists/build/languages/turkish.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWordList = void 0;
+const types_1 = require("@scrabble-solver/types");
+const lib_1 = require("../lib");
+const FILE_URL = 'https://raw.githubusercontent.com/kamilmielnik/scrabble-dictionaries/master/turkish/kelimelik.txt';
+const getWordList = async () => {
+    return (0, lib_1.getTxtWordList)(FILE_URL, types_1.Locale.TR_TR);
+};
+exports.getWordList = getWordList;

package/packages/word-lists/build/lib/downloadFile.d.ts

@@ -0,0 +1 @@
+export declare const downloadFile: (url: string) => Promise<string>;

package/packages/word-lists/build/lib/downloadFile.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = void 0;
+const follow_redirects_1 = require("follow-redirects");
+const fs_1 = __importDefault(require("fs"));
+const getTempFilepath_1 = require("./getTempFilepath");
+const downloadFile = (url) => {
+    return new Promise((resolve, reject) => {
+        const tempFilepath = (0, getTempFilepath_1.getTempFilepath)();
+        const protocol = url.startsWith('https') ? follow_redirects_1.https : follow_redirects_1.http;
+        const writeStream = fs_1.default.createWriteStream(tempFilepath);
+        const request = protocol.get(url, (response) => {
+            if (typeof response.statusCode === 'undefined' || response.statusCode >= 400) {
+                reject(new Error(`Cannot download file: ${url}`));
+                return;
+            }
+            response.on('error', (error) => {
+                writeStream.close();
+                reject(error);
+            });
+            response.on('end', () => {
+                writeStream.on('finish', () => {
+                    writeStream.close();
+                    resolve(tempFilepath);
+                });
+            });
+            response.pipe(writeStream);
+        });
+        request.on('error', (error) => {
+            writeStream.close();
+            reject(error);
+        });
+    });
+};
+exports.downloadFile = downloadFile;

package/packages/word-lists/build/lib/downloadHtml.d.ts

@@ -0,0 +1 @@
+export declare const downloadHtml: (url: string) => Promise<string>;

package/packages/word-lists/build/lib/downloadHtml.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadHtml = void 0;
+const follow_redirects_1 = require("follow-redirects");
+const downloadHtml = (url) => {
+    return new Promise((resolve, reject) => {
+        const protocol = url.startsWith('https') ? follow_redirects_1.https : follow_redirects_1.http;
+        protocol.get(url, (response) => {
+            let data = '';
+            response.setEncoding('utf8');
+            response.on('data', (chunk) => {
+                data += chunk;
+            });
+            response.on('end', () => {
+                resolve(data);
+            });
+            response.on('error', reject);
+        });
+    });
+};
+exports.downloadHtml = downloadHtml;

package/packages/word-lists/build/lib/extractWords.d.ts

@@ -0,0 +1 @@
+export declare const extractWords: (file: string, locale: string) => string[];

package/packages/word-lists/build/lib/extractWords.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractWords = void 0;
+const findFirstWordIndex_1 = require("./findFirstWordIndex");
+const extractWords = (file, locale) => {
+    const lines = file.split(/\r?\n/g);
+    const firstWordIndex = (0, findFirstWordIndex_1.findFirstWordIndex)(lines, locale);
+    const words = [];
+    for (let i = firstWordIndex; i < lines.length; ++i) {
+        const trimmed = lines[i].trim();
+        if (trimmed.length > 0) {
+            words.push(trimmed.toLocaleLowerCase());
+        }
+    }
+    return words;
+};
+exports.extractWords = extractWords;

package/packages/word-lists/build/lib/findFirstWordIndex.d.ts

@@ -0,0 +1 @@
+export declare const findFirstWordIndex: (lines: string[], locale: string) => number;

package/packages/word-lists/build/lib/findFirstWordIndex.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFirstWordIndex = void 0;
+const findFirstWordIndex = (lines, locale) => {
+    const firstWordIndex = lines.findIndex((line, index) => {
+        const nextLine = line[index + 1] || '';
+        const isNextLineInOrder = line.localeCompare(nextLine, locale) > 0;
+        const hasWhitespace = Boolean(line.match(/\s/));
+        const isEmpty = line.trim().length === 0;
+        return !isEmpty && !hasWhitespace && isNextLineInOrder;
+    });
+    if (typeof firstWordIndex === 'undefined') {
+        throw new Error('Cannot find index of the first word in the file');
+    }
+    return firstWordIndex;
+};
+exports.findFirstWordIndex = findFirstWordIndex;

package/packages/word-lists/build/lib/getHash.d.ts

@@ -0,0 +1 @@
+export declare const getHash: (bytes?: number) => string;

package/packages/word-lists/build/lib/getHash.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHash = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const getHash = (bytes = 8) => crypto_1.default.randomBytes(bytes).toString('hex');
+exports.getHash = getHash;

package/packages/word-lists/build/lib/getTempFilepath.d.ts

@@ -0,0 +1 @@
+export declare const getTempFilepath: () => string;

package/packages/word-lists/build/lib/getTempFilepath.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTempFilepath = void 0;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const getHash_1 = require("./getHash");
+const OUTPUT_DIRECTORY = path_1.default.resolve(os_1.default.homedir(), '.scrabble-solver');
+const getTempFilepath = () => {
+    const filename = `${(0, getHash_1.getHash)()}.txt`;
+    return path_1.default.join(OUTPUT_DIRECTORY, filename);
+};
+exports.getTempFilepath = getTempFilepath;

package/packages/word-lists/build/lib/getTxtWordList.d.ts

@@ -0,0 +1 @@
+export declare const getTxtWordList: (url: string, locale: string) => Promise<string[]>;

package/packages/word-lists/build/lib/getTxtWordList.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTxtWordList = void 0;
+const fs_1 = __importDefault(require("fs"));
+const downloadFile_1 = require("./downloadFile");
+const extractWords_1 = require("./extractWords");
+const getTxtWordList = async (url, locale) => {
+    const tempFilename = await (0, downloadFile_1.downloadFile)(url);
+    const file = fs_1.default.readFileSync(tempFilename, 'utf-8');
+    const words = (0, extractWords_1.extractWords)(file.toLocaleString(), locale);
+    fs_1.default.unlinkSync(tempFilename);
+    return words;
+};
+exports.getTxtWordList = getTxtWordList;

package/packages/word-lists/build/lib/index.d.ts

@@ -0,0 +1,10 @@
+export { downloadFile } from './downloadFile';
+export { downloadHtml } from './downloadHtml';
+export { extractWords } from './extractWords';
+export { findFirstWordIndex } from './findFirstWordIndex';
+export { getHash } from './getHash';
+export { getTempFilepath } from './getTempFilepath';
+export { getTxtWordList } from './getTxtWordList';
+export { transliterateDiacritics } from './transliterateDiacritics';
+export { unique } from './unique';
+export { unzip } from './unzip';

package/packages/word-lists/build/lib/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unzip = exports.unique = exports.transliterateDiacritics = exports.getTxtWordList = exports.getTempFilepath = exports.getHash = exports.findFirstWordIndex = exports.extractWords = exports.downloadHtml = exports.downloadFile = void 0;
+var downloadFile_1 = require("./downloadFile");
+Object.defineProperty(exports, "downloadFile", { enumerable: true, get: function () { return downloadFile_1.downloadFile; } });
+var downloadHtml_1 = require("./downloadHtml");
+Object.defineProperty(exports, "downloadHtml", { enumerable: true, get: function () { return downloadHtml_1.downloadHtml; } });
+var extractWords_1 = require("./extractWords");
+Object.defineProperty(exports, "extractWords", { enumerable: true, get: function () { return extractWords_1.extractWords; } });
+var findFirstWordIndex_1 = require("./findFirstWordIndex");
+Object.defineProperty(exports, "findFirstWordIndex", { enumerable: true, get: function () { return findFirstWordIndex_1.findFirstWordIndex; } });
+var getHash_1 = require("./getHash");
+Object.defineProperty(exports, "getHash", { enumerable: true, get: function () { return getHash_1.getHash; } });
+var getTempFilepath_1 = require("./getTempFilepath");
+Object.defineProperty(exports, "getTempFilepath", { enumerable: true, get: function () { return getTempFilepath_1.getTempFilepath; } });
+var getTxtWordList_1 = require("./getTxtWordList");
+Object.defineProperty(exports, "getTxtWordList", { enumerable: true, get: function () { return getTxtWordList_1.getTxtWordList; } });
+var transliterateDiacritics_1 = require("./transliterateDiacritics");
+Object.defineProperty(exports, "transliterateDiacritics", { enumerable: true, get: function () { return transliterateDiacritics_1.transliterateDiacritics; } });
+var unique_1 = require("./unique");
+Object.defineProperty(exports, "unique", { enumerable: true, get: function () { return unique_1.unique; } });
+var unzip_1 = require("./unzip");
+Object.defineProperty(exports, "unzip", { enumerable: true, get: function () { return unzip_1.unzip; } });

package/packages/word-lists/build/lib/transliterateDiacritics.d.ts

@@ -0,0 +1,2 @@
+import { transliterate } from 'transliteration';
+export declare const transliterateDiacritics: (words: string[], options?: Parameters<typeof transliterate>[1]) => string[];

package/packages/word-lists/build/lib/transliterateDiacritics.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transliterateDiacritics = void 0;
+const transliteration_1 = require("transliteration");
+const unique_1 = require("./unique");
+const transliterateDiacritics = (words, options) => {
+    return (0, unique_1.unique)(words.map((word) => (0, transliteration_1.transliterate)(word, options)));
+};
+exports.transliterateDiacritics = transliterateDiacritics;

package/packages/word-lists/build/lib/unique.d.ts

@@ -0,0 +1 @@
+export declare const unique: <T>(array: T[]) => T[];

package/packages/word-lists/build/lib/unique.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unique = void 0;
+const unique = (array) => Array.from(new Set(array));
+exports.unique = unique;

package/packages/word-lists/build/lib/unzip.d.ts

@@ -0,0 +1 @@
+export declare const unzip: (zipFilename: string, extractFilename: string, outputFilename: string) => Promise<void>;

package/packages/word-lists/build/lib/unzip.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unzip = void 0;
+const fs_1 = __importDefault(require("fs"));
+const unzipper_1 = __importDefault(require("unzipper"));
+const unzip = (zipFilename, extractFilename, outputFilename) => {
+    return fs_1.default
+        .createReadStream(zipFilename)
+        .pipe(unzipper_1.default.Parse())
+        .on('entry', (entry) => {
+        const fileName = entry.path;
+        if (fileName === extractFilename) {
+            entry.pipe(fs_1.default.createWriteStream(outputFilename));
+        }
+        else {
+            entry.autodrain();
+        }
+    })
+        .promise();
+};
+exports.unzip = unzip;

package/packages/word-lists/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@scrabble-solver/word-lists",
+  "version": "2.18.10-alpha.2",
+  "description": "Per-locale word list downloaders for Scrabble Solver (SOWPODS, TWL06, SJP, and more).",
+  "keywords": [
+    "word-list",
+    "scrabble",
+    "dictionary",
+    "sowpods",
+    "twl06",
+    "sjp"
+  ],
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kamilmielnik/scrabble-solver.git"
+  },
+  "author": {
+    "name": "Kamil Mielnik",
+    "email": "kamil@kamilmielnik.com",
+    "url": "https://kamilmielnik.com"
+  },
+  "license": "CC-BY-NC-ND-4.0",
+  "bugs": {
+    "url": "https://github.com/kamilmielnik/scrabble-solver/issues"
+  },
+  "homepage": "https://scrabble-solver.org",
+  "scripts": {
+    "build": "tsc --project .",
+    "clean": "rimraf build/"
+  },
+  "dependencies": {
+    "@scrabble-solver/types": "2.18.10-alpha.2",
+    "cheerio": "1.2.0",
+    "follow-redirects": "1.16.2",
+    "transliteration": "2.7.0",
+    "unzipper": "0.12.5"
+  },
+  "devDependencies": {
+    "@types/follow-redirects": "1.14.4",
+    "@types/unzipper": "0.10.11"
+  },
+  "gitHead": "f029a11f306a01937ee99fc6365cb226b972dfed"
+}

package/packages/word-lists/src/getWordList.ts

@@ -0,0 +1,17 @@
+import { Locale } from '@scrabble-solver/types';
+
+import { english, french, german, persian, polish, romanian, spanish, turkish } from './languages';
+
+const localeMap: Record<Locale, () => Promise<string[]>> = {
+  [Locale.DE_DE]: german.getWordList,
+  [Locale.EN_GB]: english.getWordListGb,
+  [Locale.EN_US]: english.getWordListUs,
+  [Locale.ES_ES]: spanish.getWordList,
+  [Locale.FA_IR]: persian.getWordList,
+  [Locale.FR_FR]: french.getWordList,
+  [Locale.PL_PL]: polish.getWordList,
+  [Locale.RO_RO]: romanian.getWordList,
+  [Locale.TR_TR]: turkish.getWordList,
+};
+
+export const getWordList = (locale: Locale): Promise<string[]> => localeMap[locale]();

package/packages/word-lists/src/index.ts

@@ -0,0 +1,3 @@
+export { getWordList } from './getWordList';
+export * from './languages';
+export * from './lib';

package/packages/word-lists/src/languages/english.ts

@@ -0,0 +1,16 @@
+import { Locale } from '@scrabble-solver/types';
+
+import { getTxtWordList } from '../lib';
+
+const EN_GB_FILE_URL =
+  'https://raw.githubusercontent.com/kamilmielnik/scrabble-dictionaries/refs/heads/master/english/sowpods.txt';
+const EN_US_FILE_URL =
+  'https://raw.githubusercontent.com/kamilmielnik/scrabble-dictionaries/refs/heads/master/english/twl06.txt';
+
+export const getWordListGb = async (): Promise<string[]> => {
+  return getTxtWordList(EN_GB_FILE_URL, Locale.EN_GB);
+};
+
+export const getWordListUs = async (): Promise<string[]> => {
+  return getTxtWordList(EN_US_FILE_URL, Locale.EN_US);
+};

package/packages/word-lists/src/languages/french.ts

@@ -0,0 +1,11 @@
+import { Locale } from '@scrabble-solver/types';
+
+import { getTxtWordList, transliterateDiacritics } from '../lib';
+
+const FILE_URL =
+  'https://raw.githubusercontent.com/kamilmielnik/scrabble-dictionaries/refs/heads/master/french/ods8.txt';
+
+export const getWordList = async (): Promise<string[]> => {
+  const words = await getTxtWordList(FILE_URL, Locale.FR_FR);
+  return transliterateDiacritics(words);
+};

package/packages/word-lists/src/languages/german.ts

@@ -0,0 +1,10 @@
+import { Locale } from '@scrabble-solver/types';
+
+import { getTxtWordList } from '../lib';
+
+const FILE_URL =
+  'https://raw.githubusercontent.com/kamilmielnik/scrabble-dictionaries/refs/heads/master/german/german.txt';
+
+export const getWordList = async (): Promise<string[]> => {
+  return getTxtWordList(FILE_URL, Locale.DE_DE);
+};

package/packages/word-lists/src/languages/index.ts

@@ -0,0 +1,8 @@
+export * as english from './english';
+export * as german from './german';
+export * as french from './french';
+export * as persian from './persian';
+export * as polish from './polish';
+export * as romanian from './romanian';
+export * as spanish from './spanish';
+export * as turkish from './turkish';

package/packages/word-lists/src/languages/persian.ts

@@ -0,0 +1,10 @@
+import { Locale } from '@scrabble-solver/types';
+
+import { getTxtWordList } from '../lib';
+
+const FILE_URL =
+  'https://raw.githubusercontent.com/kamilmielnik/scrabble-dictionaries/refs/heads/master/persian/persian.txt';
+
+export const getWordList = async (): Promise<string[]> => {
+  return getTxtWordList(FILE_URL, Locale.FA_IR);
+};

package/packages/word-lists/src/languages/polish.ts

@@ -0,0 +1,59 @@
+import { Locale } from '@scrabble-solver/types';
+import { load } from 'cheerio';
+import fs from 'fs';
+import { URL } from 'url';
+
+import { downloadFile, downloadHtml, extractWords, getTempFilepath, getTxtWordList, unzip } from '../lib';
+
+const PAGE_URL = 'https://sjp.pl/sl/growy/';
+const FILE_TO_EXTRACT_FROM_ZIP = 'slowa.txt';
+const REASONABLE_VALID_WORD_COUNT_TRESHOLD = 2_000_000; // more like 3M, but just to be safe
+const SECONDARY_FILE_URL =
+  'https://raw.githubusercontent.com/kamilmielnik/scrabble-dictionaries/refs/heads/master/polish/sjp.txt';
+
+export const getWordList = async (): Promise<string[]> => {
+  try {
+    const tempFilepath = getTempFilepath();
+    const zipUrl = await fetchZipUrl(PAGE_URL);
+    const zipTempFilename = await downloadFile(zipUrl);
+    await unzip(zipTempFilename, FILE_TO_EXTRACT_FROM_ZIP, tempFilepath);
+    fs.unlinkSync(zipTempFilename);
+    const file = fs.readFileSync(tempFilepath, 'utf-8');
+    fs.unlinkSync(tempFilepath);
+    const words = extractWords(file.toLocaleString(), 'pl-PL');
+
+    if (words.length < REASONABLE_VALID_WORD_COUNT_TRESHOLD) {
+      return getBackupWordList();
+    }
+
+    return words;
+  } catch {
+    return getBackupWordList();
+  }
+};
+
+const fetchZipUrl = async (url: string): Promise<string> => {
+  const html = await downloadHtml(url);
+  const filename = parseZipContainingPage(html);
+  const { href } = new URL(filename, url);
+  return href;
+};
+
+const parseZipContainingPage = (html: string): string => {
+  const $ = load(html);
+  const $links = $('a');
+  const links = Array.from($links)
+    .map((link) => $(link).attr('href'))
+    .filter(Boolean) as string[];
+  const zipFilename = links.find((link) => link.endsWith('.zip'));
+
+  if (typeof zipFilename === 'undefined') {
+    throw new Error('Cannot find link to zip file on the page');
+  }
+
+  return zipFilename;
+};
+
+const getBackupWordList = () => {
+  return getTxtWordList(SECONDARY_FILE_URL, Locale.PL_PL);
+};

package/packages/word-lists/src/languages/romanian.ts

@@ -0,0 +1,10 @@
+import { Locale } from '@scrabble-solver/types';
+
+import { getTxtWordList, transliterateDiacritics } from '../lib';
+
+const FILE_URL = 'https://raw.githubusercontent.com/kamilmielnik/scrabble-dictionaries/master/romanian/loc-5.0.txt';
+
+export const getWordList = async (): Promise<string[]> => {
+  const words = await getTxtWordList(FILE_URL, Locale.RO_RO);
+  return transliterateDiacritics(words);
+};

package/packages/word-lists/src/languages/spanish.ts

@@ -0,0 +1,10 @@
+import { Locale } from '@scrabble-solver/types';
+
+import { getTxtWordList, transliterateDiacritics } from '../lib';
+
+const FILE_URL = 'https://raw.githubusercontent.com/kamilmielnik/scrabble-dictionaries/master/spanish/file-2017.txt';
+
+export const getWordList = async (): Promise<string[]> => {
+  const words = await getTxtWordList(FILE_URL, Locale.ES_ES);
+  return transliterateDiacritics(words, { ignore: ['ñ'] });
+};

package/packages/word-lists/src/languages/turkish.ts

@@ -0,0 +1,9 @@
+import { Locale } from '@scrabble-solver/types';
+
+import { getTxtWordList } from '../lib';
+
+const FILE_URL = 'https://raw.githubusercontent.com/kamilmielnik/scrabble-dictionaries/master/turkish/kelimelik.txt';
+
+export const getWordList = async (): Promise<string[]> => {
+  return getTxtWordList(FILE_URL, Locale.TR_TR);
+};

package/packages/word-lists/src/lib/downloadFile.ts

@@ -0,0 +1,37 @@
+import { http, https } from 'follow-redirects';
+import fs from 'fs';
+
+import { getTempFilepath } from './getTempFilepath';
+
+export const downloadFile = (url: string): Promise<string> => {
+  return new Promise((resolve, reject) => {
+    const tempFilepath = getTempFilepath();
+    const protocol = url.startsWith('https') ? https : http;
+    const writeStream = fs.createWriteStream(tempFilepath);
+    const request = protocol.get(url, (response) => {
+      if (typeof response.statusCode === 'undefined' || response.statusCode >= 400) {
+        reject(new Error(`Cannot download file: ${url}`));
+        return;
+      }
+
+      response.on('error', (error) => {
+        writeStream.close();
+        reject(error);
+      });
+
+      response.on('end', () => {
+        writeStream.on('finish', () => {
+          writeStream.close();
+          resolve(tempFilepath);
+        });
+      });
+
+      response.pipe(writeStream);
+    });
+
+    request.on('error', (error) => {
+      writeStream.close();
+      reject(error);
+    });
+  });
+};