@scrabble-solver/scrabble-solver 2.7.2 → 2.8.1

package/.next/server/pages/api/solve.js

@@ -1,160 +1,944 @@
-module.exports =
-/******/ (function(modules) { // webpackBootstrap
-/******/ 	// The module cache
-/******/ 	var installedModules = require('../../ssr-module-cache.js');
-/******/
-/******/ 	// The require function
-/******/ 	function __webpack_require__(moduleId) {
-/******/
-/******/ 		// Check if module is in cache
-/******/ 		if(installedModules[moduleId]) {
-/******/ 			return installedModules[moduleId].exports;
-/******/ 		}
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = installedModules[moduleId] = {
-/******/ 			i: moduleId,
-/******/ 			l: false,
-/******/ 			exports: {}
-/******/ 		};
-/******/
-/******/ 		// Execute the module function
-/******/ 		var threw = true;
-/******/ 		try {
-/******/ 			modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-/******/ 			threw = false;
-/******/ 		} finally {
-/******/ 			if(threw) delete installedModules[moduleId];
-/******/ 		}
-/******/
-/******/ 		// Flag the module as loaded
-/******/ 		module.l = true;
-/******/
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
-/******/
-/******/
-/******/ 	// expose the modules object (__webpack_modules__)
-/******/ 	__webpack_require__.m = modules;
-/******/
-/******/ 	// expose the module cache
-/******/ 	__webpack_require__.c = installedModules;
-/******/
-/******/ 	// define getter function for harmony exports
-/******/ 	__webpack_require__.d = function(exports, name, getter) {
-/******/ 		if(!__webpack_require__.o(exports, name)) {
-/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
-/******/ 		}
-/******/ 	};
-/******/
-/******/ 	// define __esModule on exports
-/******/ 	__webpack_require__.r = function(exports) {
-/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-/******/ 		}
-/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
-/******/ 	};
-/******/
-/******/ 	// create a fake namespace object
-/******/ 	// mode & 1: value is a module id, require it
-/******/ 	// mode & 2: merge all properties of value into the ns
-/******/ 	// mode & 4: return value when already ns object
-/******/ 	// mode & 8|1: behave like require
-/******/ 	__webpack_require__.t = function(value, mode) {
-/******/ 		if(mode & 1) value = __webpack_require__(value);
-/******/ 		if(mode & 8) return value;
-/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
-/******/ 		var ns = Object.create(null);
-/******/ 		__webpack_require__.r(ns);
-/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
-/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
-/******/ 		return ns;
-/******/ 	};
-/******/
-/******/ 	// getDefaultExport function for compatibility with non-harmony modules
-/******/ 	__webpack_require__.n = function(module) {
-/******/ 		var getter = module && module.__esModule ?
-/******/ 			function getDefault() { return module['default']; } :
-/******/ 			function getModuleExports() { return module; };
-/******/ 		__webpack_require__.d(getter, 'a', getter);
-/******/ 		return getter;
-/******/ 	};
-/******/
-/******/ 	// Object.prototype.hasOwnProperty.call
-/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
-/******/
-/******/ 	// __webpack_public_path__
-/******/ 	__webpack_require__.p = "";
-/******/
-/******/
-/******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = 4);
-/******/ })
-/************************************************************************/
-/******/ ({
-
-/***/ 4:
-/***/ (function(module, exports, __webpack_require__) {
-
-module.exports = __webpack_require__("YAif");
-
-
-/***/ }),
-
-/***/ "93xF":
-/***/ (function(module, exports) {
-
-module.exports = require("@scrabble-solver/dictionaries");
-
-/***/ }),
-
-/***/ "AVDn":
-/***/ (function(module, exports) {
-
-module.exports = require("@scrabble-solver/logger");
-
-/***/ }),
-
-/***/ "DiT0":
-/***/ (function(module, exports) {
-
-module.exports = require("@scrabble-solver/configs");
-
-/***/ }),
-
-/***/ "E2kR":
-/***/ (function(module, exports) {
-
-module.exports = require("@scrabble-solver/types");
-
-/***/ }),
+"use strict";
+(() => {
+var exports = {};
+exports.id = 87;
+exports.ids = [87];
+exports.modules = {
 
-/***/ "Y84q":
-/***/ (function(module, exports) {
+/***/ 60871:
+/***/ ((module) => {
 
-module.exports = require("@scrabble-solver/solver");
+module.exports = require("buffer");
 
 /***/ }),
 
-/***/ "YAif":
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+/***/ 96974:
+/***/ ((module) => {
+
+module.exports = require("debug");
+
+/***/ }),
+
+/***/ 39491:
+/***/ ((module) => {
+
+module.exports = require("assert");
+
+/***/ }),
+
+/***/ 22057:
+/***/ ((module) => {
+
+module.exports = require("constants");
+
+/***/ }),
+
+/***/ 6113:
+/***/ ((module) => {
+
+module.exports = require("crypto");
+
+/***/ }),
+
+/***/ 82361:
+/***/ ((module) => {
+
+module.exports = require("events");
+
+/***/ }),
+
+/***/ 57147:
+/***/ ((module) => {
+
+module.exports = require("fs");
+
+/***/ }),
+
+/***/ 13685:
+/***/ ((module) => {
+
+module.exports = require("http");
+
+/***/ }),
+
+/***/ 95687:
+/***/ ((module) => {
+
+module.exports = require("https");
+
+/***/ }),
+
+/***/ 22037:
+/***/ ((module) => {
+
+module.exports = require("os");
+
+/***/ }),
+
+/***/ 71017:
+/***/ ((module) => {
+
+module.exports = require("path");
+
+/***/ }),
+
+/***/ 77282:
+/***/ ((module) => {
+
+module.exports = require("process");
+
+/***/ }),
+
+/***/ 12781:
+/***/ ((module) => {
+
+module.exports = require("stream");
+
+/***/ }),
+
+/***/ 71576:
+/***/ ((module) => {
+
+module.exports = require("string_decoder");
+
+/***/ }),
+
+/***/ 57310:
+/***/ ((module) => {
+
+module.exports = require("url");
+
+/***/ }),
+
+/***/ 73837:
+/***/ ((module) => {
+
+module.exports = require("util");
+
+/***/ }),
+
+/***/ 59796:
+/***/ ((module) => {
+
+module.exports = require("zlib");
+
+/***/ }),
+
+/***/ 21285:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var logger_1 = __importDefault(__webpack_require__(52954));
+var types_1 = __webpack_require__(46452);
+var fs_1 = __importDefault(__webpack_require__(57147));
+var constants_1 = __webpack_require__(75823);
+var lib_1 = __webpack_require__(26137);
+var Dictionaries = /** @class */ (function () {
+    function Dictionaries() {
+        this.cache = new lib_1.LayeredCache();
+        this.downloadDictionaryProxies = Object.fromEntries(Object.values(types_1.Locale).map(function (locale) { return [locale, (0, lib_1.createAsyncProxy)(function () { return (0, lib_1.downloadDictionary)(locale); })]; }));
+    }
+    Dictionaries.prototype.get = function (locale) {
+        return __awaiter(this, void 0, void 0, function () {
+            var trie;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.cache.has(locale)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.cache.get(locale)];
+                    case 1:
+                        trie = _a.sent();
+                        if (trie) {
+                            return [2 /*return*/, trie];
+                        }
+                        _a.label = 2;
+                    case 2:
+                        logger_1.default.info('Dictionaries - cache miss', { locale: locale });
+                        return [2 /*return*/, this.updateDictionary(locale)];
+                }
+            });
+        });
+    };
+    Dictionaries.prototype.remove = function () {
+        fs_1.default.rmdirSync(constants_1.OUTPUT_DIRECTORY, { recursive: true });
+    };
+    Dictionaries.prototype.update = function (force) {
+        return __awaiter(this, void 0, void 0, function () {
+            var locales;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        locales = force ? Object.values(types_1.Locale) : this.getLocalesToUpdate();
+                        logger_1.default.info('Dictionaries - update', { force: force, locales: locales });
+                        return [4 /*yield*/, Promise.all(locales.map(function (locale) { return _this.updateDictionary(locale); }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Dictionaries.prototype.getLocalesToUpdate = function () {
+        var _this = this;
+        return Object.values(types_1.Locale).filter(function (locale) { return _this.cache.isStale(locale) !== false; });
+    };
+    Dictionaries.prototype.updateDictionary = function (locale) {
+        return __awaiter(this, void 0, void 0, function () {
+            var downloadDictionaryProxy, trie;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        logger_1.default.info('Dictionaries - updateDictionary', { locale: locale });
+                        fs_1.default.mkdirSync(constants_1.OUTPUT_DIRECTORY, { recursive: true });
+                        downloadDictionaryProxy = this.downloadDictionaryProxies[locale];
+                        return [4 /*yield*/, downloadDictionaryProxy()];
+                    case 1:
+                        trie = _a.sent();
+                        return [4 /*yield*/, this.cache.set(locale, trie)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, trie];
+                }
+            });
+        });
+    };
+    return Dictionaries;
+}());
+exports["default"] = Dictionaries;
+
+
+/***/ }),
+
+/***/ 75823:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.OUTPUT_DIRECTORY = exports.CACHE_STALE_THRESHOLD = exports.DAY = void 0;
+var os_1 = __importDefault(__webpack_require__(22037));
+var path_1 = __importDefault(__webpack_require__(71017));
+exports.DAY = 24 * 60 * 60 * 1000;
+exports.CACHE_STALE_THRESHOLD = 30 * exports.DAY;
+exports.OUTPUT_DIRECTORY = path_1.default.resolve(os_1.default.homedir(), '.scrabble-solver', 'dictionaries');
+
+
+/***/ }),
+
+/***/ 89044:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.dictionaries = void 0;
+var Dictionaries_1 = __importDefault(__webpack_require__(21285));
+__exportStar(__webpack_require__(26137), exports);
+exports.dictionaries = new Dictionaries_1.default();
+
+
+/***/ }),
+
+/***/ 2812:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var trie_1 = __webpack_require__(83140);
+var fs_1 = __importDefault(__webpack_require__(57147));
+var constants_1 = __webpack_require__(75823);
+var getDictionaryFilepath_1 = __importDefault(__webpack_require__(68638));
+var readFile_1 = __importDefault(__webpack_require__(61908));
+var writeFile_1 = __importDefault(__webpack_require__(42213));
+var DiskCache = /** @class */ (function () {
+    function DiskCache() {
+    }
+    DiskCache.prototype.get = function (locale) {
+        return __awaiter(this, void 0, void 0, function () {
+            var filepath, serialized, trie;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.has(locale)) {
+                            return [2 /*return*/, undefined];
+                        }
+                        filepath = (0, getDictionaryFilepath_1.default)(locale);
+                        return [4 /*yield*/, (0, readFile_1.default)(filepath)];
+                    case 1:
+                        serialized = _a.sent();
+                        trie = trie_1.Trie.deserialize(serialized);
+                        return [2 /*return*/, trie];
+                }
+            });
+        });
+    };
+    DiskCache.prototype.getLastModifiedTimestamp = function (locale) {
+        var filepath = (0, getDictionaryFilepath_1.default)(locale);
+        if (!fs_1.default.existsSync(filepath)) {
+            return undefined;
+        }
+        var stats = fs_1.default.statSync(filepath);
+        return stats.mtimeMs;
+    };
+    DiskCache.prototype.has = function (locale) {
+        var filepath = (0, getDictionaryFilepath_1.default)(locale);
+        return fs_1.default.existsSync(filepath);
+    };
+    DiskCache.prototype.isStale = function (locale) {
+        if (!this.has(locale)) {
+            return undefined;
+        }
+        var lastModifiedTimestamp = this.getLastModifiedTimestamp(locale);
+        if (typeof lastModifiedTimestamp === 'undefined') {
+            return undefined;
+        }
+        var timeSinceModification = Math.abs(lastModifiedTimestamp - Date.now());
+        return timeSinceModification > constants_1.CACHE_STALE_THRESHOLD;
+    };
+    DiskCache.prototype.set = function (locale, trie) {
+        return __awaiter(this, void 0, void 0, function () {
+            var filepath;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        filepath = (0, getDictionaryFilepath_1.default)(locale);
+                        return [4 /*yield*/, (0, writeFile_1.default)(filepath, trie.serialize())];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return DiskCache;
+}());
+exports["default"] = DiskCache;
+
+
+/***/ }),
+
+/***/ 70287:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var createCacheTimestampComparator_1 = __importDefault(__webpack_require__(20494));
+var DiskCache_1 = __importDefault(__webpack_require__(2812));
+var MemoryCache_1 = __importDefault(__webpack_require__(50192));
+var LayeredCache = /** @class */ (function () {
+    function LayeredCache() {
+        this.layers = [new MemoryCache_1.default(), new DiskCache_1.default()];
+    }
+    LayeredCache.prototype.get = function (locale) {
+        var cached = this.getLastModifiedLayer(locale);
+        if (!cached) {
+            return Promise.resolve(undefined);
+        }
+        return cached.get(locale);
+    };
+    LayeredCache.prototype.getLastModifiedTimestamp = function (locale) {
+        var cached = this.getLastModifiedLayer(locale);
+        if (!cached) {
+            return undefined;
+        }
+        return cached.getLastModifiedTimestamp(locale);
+    };
+    LayeredCache.prototype.has = function (locale) {
+        return this.layers.some(function (cache) { return cache.has(locale); });
+    };
+    LayeredCache.prototype.isStale = function (locale) {
+        if (this.layers.some(function (cache) { return cache.isStale(locale); })) {
+            return true;
+        }
+        if (this.layers.every(function (cache) { return typeof cache.isStale(locale) === 'undefined'; })) {
+            return undefined;
+        }
+        return false;
+    };
+    LayeredCache.prototype.set = function (locale, trie) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(this.layers.map(function (cache) { return cache.set(locale, trie); }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    LayeredCache.prototype.getLastModifiedLayer = function (locale) {
+        var layers = this.layers.filter(function (cache) { return cache.has(locale); });
+        var _a = __read(__spreadArray([], __read(layers), false).sort((0, createCacheTimestampComparator_1.default)(locale)), 1), cached = _a[0];
+        return cached;
+    };
+    return LayeredCache;
+}());
+exports["default"] = LayeredCache;
+
+
+/***/ }),
+
+/***/ 50192:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var constants_1 = __webpack_require__(75823);
+var MemoryCache = /** @class */ (function () {
+    function MemoryCache() {
+        this.cache = {};
+        this.cacheTimestamps = {};
+    }
+    MemoryCache.prototype.get = function (locale) {
+        return Promise.resolve(this.cache[locale]);
+    };
+    MemoryCache.prototype.getLastModifiedTimestamp = function (locale) {
+        return this.cacheTimestamps[locale];
+    };
+    MemoryCache.prototype.has = function (locale) {
+        return typeof this.cache[locale] !== 'undefined';
+    };
+    MemoryCache.prototype.isStale = function (locale) {
+        var timestamp = this.getLastModifiedTimestamp(locale);
+        if (!this.has(locale) || typeof timestamp === 'undefined') {
+            return undefined;
+        }
+        var timeSinceModification = Math.abs(timestamp - Date.now());
+        return timeSinceModification > constants_1.CACHE_STALE_THRESHOLD;
+    };
+    MemoryCache.prototype.set = function (locale, trie) {
+        this.cacheTimestamps[locale] = Date.now();
+        this.cache[locale] = trie;
+        return Promise.resolve();
+    };
+    return MemoryCache;
+}());
+exports["default"] = MemoryCache;
+
+
+/***/ }),
+
+/***/ 26554:
+/***/ (function(__unused_webpack_module, exports) {
+
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var createAsyncProxy = function (asyncCallback) {
+    var promise = null;
+    return function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (promise) {
+                        return [2 /*return*/, promise];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, , 3, 4]);
+                    promise = asyncCallback();
+                    return [4 /*yield*/, promise];
+                case 2: return [2 /*return*/, _a.sent()];
+                case 3:
+                    promise = null;
+                    return [7 /*endfinally*/];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); };
+};
+exports["default"] = createAsyncProxy;
+
+
+/***/ }),
+
+/***/ 20494:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var createCacheTimestampComparator = function (locale) {
+    return function (a, b) {
+        var aTimestamp = a.getLastModifiedTimestamp(locale);
+        var bTimestamp = b.getLastModifiedTimestamp(locale);
+        if (aTimestamp === bTimestamp) {
+            return 0;
+        }
+        if (typeof aTimestamp === 'undefined') {
+            return 1;
+        }
+        if (typeof bTimestamp === 'undefined') {
+            return -1;
+        }
+        return bTimestamp - aTimestamp;
+    };
+};
+exports["default"] = createCacheTimestampComparator;
+
+
+/***/ }),
+
+/***/ 41281:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var trie_1 = __webpack_require__(83140);
+var logger_1 = __importDefault(__webpack_require__(52954));
+var word_lists_1 = __webpack_require__(51585);
+var downloadDictionary = function (locale) { return __awaiter(void 0, void 0, void 0, function () {
+    var words, trie;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                logger_1.default.info('downloadDictionary', { locale: locale });
+                return [4 /*yield*/, (0, word_lists_1.getWordList)(locale)];
+            case 1:
+                words = _a.sent();
+                logger_1.default.info('downloadDictionary - success', { locale: locale });
+                trie = trie_1.Trie.fromArray(words);
+                return [2 /*return*/, trie];
+        }
+    });
+}); };
+exports["default"] = downloadDictionary;
+
+
+/***/ }),
+
+/***/ 68638:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var path_1 = __importDefault(__webpack_require__(71017));
+var constants_1 = __webpack_require__(75823);
+var getDictionaryFilepath = function (locale) {
+    return path_1.default.resolve(constants_1.OUTPUT_DIRECTORY, "".concat(locale, ".txt"));
+};
+exports["default"] = getDictionaryFilepath;
+
+
+/***/ }),
+
+/***/ 26137:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.writeFile = exports.readFile = exports.MemoryCache = exports.LayeredCache = exports.getDictionaryFilepath = exports.downloadDictionary = exports.DiskCache = exports.createCacheTimestampComparator = exports.createAsyncProxy = void 0;
+var createAsyncProxy_1 = __webpack_require__(26554);
+Object.defineProperty(exports, "createAsyncProxy", ({ enumerable: true, get: function () { return __importDefault(createAsyncProxy_1).default; } }));
+var createCacheTimestampComparator_1 = __webpack_require__(20494);
+Object.defineProperty(exports, "createCacheTimestampComparator", ({ enumerable: true, get: function () { return __importDefault(createCacheTimestampComparator_1).default; } }));
+var DiskCache_1 = __webpack_require__(2812);
+Object.defineProperty(exports, "DiskCache", ({ enumerable: true, get: function () { return __importDefault(DiskCache_1).default; } }));
+var downloadDictionary_1 = __webpack_require__(41281);
+Object.defineProperty(exports, "downloadDictionary", ({ enumerable: true, get: function () { return __importDefault(downloadDictionary_1).default; } }));
+var getDictionaryFilepath_1 = __webpack_require__(68638);
+Object.defineProperty(exports, "getDictionaryFilepath", ({ enumerable: true, get: function () { return __importDefault(getDictionaryFilepath_1).default; } }));
+var LayeredCache_1 = __webpack_require__(70287);
+Object.defineProperty(exports, "LayeredCache", ({ enumerable: true, get: function () { return __importDefault(LayeredCache_1).default; } }));
+var MemoryCache_1 = __webpack_require__(50192);
+Object.defineProperty(exports, "MemoryCache", ({ enumerable: true, get: function () { return __importDefault(MemoryCache_1).default; } }));
+var readFile_1 = __webpack_require__(61908);
+Object.defineProperty(exports, "readFile", ({ enumerable: true, get: function () { return __importDefault(readFile_1).default; } }));
+var writeFile_1 = __webpack_require__(42213);
+Object.defineProperty(exports, "writeFile", ({ enumerable: true, get: function () { return __importDefault(writeFile_1).default; } }));
+
+
+/***/ }),
+
+/***/ 61908:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var fs_1 = __importDefault(__webpack_require__(57147));
+var readFile = function (filepath) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, new Promise(function (resolve, reject) {
+                fs_1.default.readFile(filepath, { encoding: 'utf-8' }, function (error, data) {
+                    if (error) {
+                        reject();
+                    }
+                    else {
+                        resolve(data.toString());
+                    }
+                });
+            })];
+    });
+}); };
+exports["default"] = readFile;
+
+
+/***/ }),
+
+/***/ 42213:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var fs_1 = __importDefault(__webpack_require__(57147));
+var writeFile = function (filepath, data) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, new Promise(function (resolve, reject) {
+                fs_1.default.writeFile(filepath, data, function (error) {
+                    if (error) {
+                        reject();
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            })];
+    });
+}); };
+exports["default"] = writeFile;
+
+
+/***/ }),
+
+/***/ 38104:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-"use strict";
 __webpack_require__.r(__webpack_exports__);
-/* harmony import */ var _scrabble_solver_configs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("DiT0");
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _scrabble_solver_configs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(27911);
 /* harmony import */ var _scrabble_solver_configs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_configs__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _scrabble_solver_constants__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("h+wf");
-/* harmony import */ var _scrabble_solver_constants__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_constants__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var _scrabble_solver_dictionaries__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("93xF");
+/* harmony import */ var _scrabble_solver_constants__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(38436);
+/* harmony import */ var _scrabble_solver_dictionaries__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(89044);
 /* harmony import */ var _scrabble_solver_dictionaries__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_dictionaries__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("AVDn");
+/* harmony import */ var _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(52954);
 /* harmony import */ var _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_3__);
-/* harmony import */ var _scrabble_solver_solver__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("Y84q");
+/* harmony import */ var _scrabble_solver_solver__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(40368);
 /* harmony import */ var _scrabble_solver_solver__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_solver__WEBPACK_IMPORTED_MODULE_4__);
-/* harmony import */ var _scrabble_solver_types__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("E2kR");
+/* harmony import */ var _scrabble_solver_types__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(46452);
 /* harmony import */ var _scrabble_solver_types__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_scrabble_solver_types__WEBPACK_IMPORTED_MODULE_5__);
-/* harmony import */ var api__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("efbE");
-
+/* harmony import */ var api__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(53888);
 
 
 
@@ -162,342 +946,1103 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-const solve = async (request, response) => {
-  const meta = Object(api__WEBPACK_IMPORTED_MODULE_6__[/* getServerLoggingData */ "a"])(request);
-
-  try {
-    const {
-      board,
-      characters,
-      config,
-      locale
-    } = parseRequest(request);
-    _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_3___default.a.info('solve - request', {
-      meta,
-      payload: {
-        board: board.toString(),
-        boardBlanksCount: board.getBlanksCount(),
-        boardTilesCount: board.getTilesCount(),
-        characters: characters.join(''),
-        configId: request.body.configId,
+const solve = async (request, response)=>{
+    const meta = (0,api__WEBPACK_IMPORTED_MODULE_6__/* .getServerLoggingData */ .X8)(request);
+    try {
+        const { board , characters , config , locale  } = parseRequest(request);
+        _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_3___default().info("solve - request", {
+            meta,
+            payload: {
+                board: board.toString(),
+                boardBlanksCount: board.getBlanksCount(),
+                boardTilesCount: board.getTilesCount(),
+                characters: characters.join(""),
+                configId: request.body.configId,
+                locale
+            }
+        });
+        validateRequest({
+            board,
+            characters,
+            config,
+            locale
+        });
+        const trie = await _scrabble_solver_dictionaries__WEBPACK_IMPORTED_MODULE_2__.dictionaries.get(locale);
+        const tiles = characters.map((character)=>new _scrabble_solver_types__WEBPACK_IMPORTED_MODULE_5__.Tile({
+                character,
+                isBlank: character === _scrabble_solver_constants__WEBPACK_IMPORTED_MODULE_1__.BLANK
+            }));
+        const solver = new (_scrabble_solver_solver__WEBPACK_IMPORTED_MODULE_4___default())(config, trie);
+        const results = solver.solve(board, tiles);
+        response.status(200).send(results.map((result)=>result.toJson()));
+    } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_3___default().error("solve - error", {
+            error,
+            meta
+        });
+        response.status(500).send({
+            error: "Server error",
+            message
+        });
+    }
+};
+const parseRequest = (request)=>{
+    const { board , characters , configId , locale  } = request.body;
+    (0,api__WEBPACK_IMPORTED_MODULE_6__/* .validateConfigId */ .Qm)(configId);
+    (0,api__WEBPACK_IMPORTED_MODULE_6__/* .validateLocale */ .Qb)(locale);
+    const config = (0,_scrabble_solver_configs__WEBPACK_IMPORTED_MODULE_0__.getLocaleConfig)(configId, locale);
+    (0,api__WEBPACK_IMPORTED_MODULE_6__/* .validateBoard */ .U4)(board, config);
+    (0,api__WEBPACK_IMPORTED_MODULE_6__/* .validateCharacters */ .EN)(characters, config);
+    return {
+        board: _scrabble_solver_types__WEBPACK_IMPORTED_MODULE_5__.Board.fromJson(board),
+        characters,
+        config,
         locale
-      }
-    });
-    validateRequest({
-      board,
-      characters,
-      config,
-      locale
-    });
-    const trie = await _scrabble_solver_dictionaries__WEBPACK_IMPORTED_MODULE_2__["dictionaries"].get(locale);
-    const tiles = characters.map(character => new _scrabble_solver_types__WEBPACK_IMPORTED_MODULE_5__["Tile"]({
-      character,
-      isBlank: character === _scrabble_solver_constants__WEBPACK_IMPORTED_MODULE_1__["BLANK"]
-    }));
-    const solver = new _scrabble_solver_solver__WEBPACK_IMPORTED_MODULE_4___default.a(config, trie);
-    const results = solver.solve(board, tiles);
-    response.status(200).send(results.map(result => result.toJson()));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    _scrabble_solver_logger__WEBPACK_IMPORTED_MODULE_3___default.a.error('solve - error', {
-      error,
-      meta
-    });
-    response.status(500).send({
-      error: 'Server error',
-      message
-    });
-  }
+    };
+};
+const validateRequest = ({ board , characters , config  })=>{
+    const blankTilesCount = characters.filter((character)=>character === _scrabble_solver_constants__WEBPACK_IMPORTED_MODULE_1__.BLANK).length;
+    const blanksCount = board.getBlanksCount() + blankTilesCount;
+    if (blanksCount > config.numberOfBlanks) {
+        throw new Error(`Too many blank tiles passed (board: ${board.getBlanksCount()}, tiles: ${blankTilesCount})`);
+    }
 };
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (solve);
+
+
+/***/ }),
+
+/***/ 6700:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
 
-const parseRequest = request => {
-  const {
-    board,
-    characters,
-    configId,
-    locale
-  } = request.body;
-  Object(api__WEBPACK_IMPORTED_MODULE_6__[/* validateConfigId */ "d"])(configId);
-  Object(api__WEBPACK_IMPORTED_MODULE_6__[/* validateLocale */ "e"])(locale);
-  const config = Object(_scrabble_solver_configs__WEBPACK_IMPORTED_MODULE_0__["getLocaleConfig"])(configId, locale);
-  Object(api__WEBPACK_IMPORTED_MODULE_6__[/* validateBoard */ "b"])(board, config);
-  Object(api__WEBPACK_IMPORTED_MODULE_6__[/* validateCharacters */ "c"])(characters, config);
-  return {
-    board: _scrabble_solver_types__WEBPACK_IMPORTED_MODULE_5__["Board"].fromJson(board),
-    characters,
-    config,
-    locale
-  };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 };
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var constants_1 = __webpack_require__(38436);
+var types_1 = __webpack_require__(46452);
+var PatternsFiller = /** @class */ (function () {
+    function PatternsFiller(config, trie) {
+        this.config = config;
+        this.trie = trie;
+    }
+    PatternsFiller.prototype.fill = function (pattern, tiles) {
+        var patterns = [];
+        if (pattern.getNumberOfEmptyCells() > tiles.length) {
+            return [];
+        }
+        var onPatternFound = function (newPattern) { return patterns.push(newPattern); };
+        var tilesPermutations = this.generateBlankTilesPermutations(tiles);
+        for (var index = 0; index < tilesPermutations.length; ++index) {
+            var tilesPermutation = tilesPermutations[index];
+            this.fillPattern(pattern, String(pattern), tilesPermutation, onPatternFound);
+        }
+        return patterns;
+    };
+    PatternsFiller.prototype.fillPattern = function (pattern, word, tiles, onPatternFound) {
+        var indexOfFirstCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
+        if (indexOfFirstCellWithoutTile === -1) {
+            if (this.canAddPattern(pattern, word)) {
+                onPatternFound(pattern.clone());
+            }
+        }
+        else {
+            for (var index = 0; index < tiles.length; ++index) {
+                var tile = tiles[index];
+                var remainingTiles = tiles.slice(0, index).concat(tiles.slice(index + 1));
+                var previousTile = pattern.cells[indexOfFirstCellWithoutTile].tile;
+                pattern.cells[indexOfFirstCellWithoutTile].tile = tile;
+                var indexOfNextCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
+                var indexOfFirstEmptyLetter = word.indexOf(constants_1.EMPTY_CELL);
+                var newWordPrefix = word.substring(0, indexOfFirstEmptyLetter) + tile.character;
+                var newWord = newWordPrefix + word.substring(indexOfFirstEmptyLetter + 1);
+                if (indexOfNextCellWithoutTile === -1) {
+                    if (this.canAddPattern(pattern, newWord)) {
+                        onPatternFound(pattern.clone());
+                    }
+                }
+                else if (this.trie.hasPrefix(newWordPrefix)) {
+                    this.fillPattern(pattern, newWord, remainingTiles, onPatternFound);
+                }
+                pattern.cells[indexOfFirstCellWithoutTile].tile = previousTile;
+            }
+        }
+    };
+    PatternsFiller.prototype.canAddPattern = function (pattern, word) {
+        var _this = this;
+        return (this.trie.has(word) &&
+            pattern
+                .getCollisions()
+                .map(String)
+                .every(function (collision) { return _this.trie.has(collision); }));
+    };
+    PatternsFiller.prototype.generateBlankTilesPermutations = function (tiles) {
+        var _this = this;
+        var alphabet = this.config.alphabet;
+        var firstBlankIndex = tiles.findIndex(function (_a) {
+            var character = _a.character, isBlank = _a.isBlank;
+            return isBlank && !alphabet.includes(character);
+        });
+        if (firstBlankIndex === -1) {
+            return [tiles];
+        }
+        var remainingTiles = tiles.slice(0, firstBlankIndex).concat(tiles.slice(firstBlankIndex + 1));
+        return this.config.alphabet.reduce(function (permutations, character) {
+            var newTile = new types_1.Tile({ character: character, isBlank: true });
+            var newTiles = __spreadArray(__spreadArray([], __read(remainingTiles), false), [newTile], false);
+            return permutations.concat(_this.generateBlankTilesPermutations(newTiles));
+        }, []);
+    };
+    return PatternsFiller;
+}());
+exports["default"] = PatternsFiller;
+
+
+/***/ }),
+
+/***/ 34196:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-const validateRequest = ({
-  board,
-  characters,
-  config
-}) => {
-  const blankTilesCount = characters.filter(character => character === _scrabble_solver_constants__WEBPACK_IMPORTED_MODULE_1__["BLANK"]).length;
-  const blanksCount = board.getBlanksCount() + blankTilesCount;
 
-  if (blanksCount > config.numberOfBlanks) {
-    throw new Error(`Too many blank tiles passed (board: ${board.getBlanksCount()}, tiles: ${blankTilesCount})`);
-  }
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 };
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var types_1 = __webpack_require__(46452);
+var PatternsGenerator = /** @class */ (function () {
+    function PatternsGenerator(config) {
+        this.config = config;
+    }
+    PatternsGenerator.prototype.generate = function (board) {
+        return __spreadArray(__spreadArray([], __read(this.generateHorizontal(board)), false), __read(this.generateVertical(board)), false);
+    };
+    PatternsGenerator.prototype.generateHorizontal = function (board) {
+        return this.generatePatterns({
+            board: board,
+            getNthVector: function (index) { return board.getRow(index); },
+            numberOfVectors: this.config.boardHeight,
+            PatternModel: types_1.HorizontalPattern,
+        });
+    };
+    PatternsGenerator.prototype.generateVertical = function (board) {
+        return this.generatePatterns({
+            board: board,
+            getNthVector: function (index) { return board.getColumn(index); },
+            numberOfVectors: this.config.boardWidth,
+            PatternModel: types_1.VerticalPattern,
+        });
+    };
+    PatternsGenerator.prototype.generatePatterns = function (_a) {
+        var _this = this;
+        var board = _a.board, getNthVector = _a.getNthVector, numberOfVectors = _a.numberOfVectors, PatternModel = _a.PatternModel;
+        return this.generateVectors({ getNthVector: getNthVector, numberOfVectors: numberOfVectors }).reduce(function (patterns, cells) {
+            return patterns.concat(_this.generateCellsPatterns({ board: board, PatternModel: PatternModel, cells: cells }));
+        }, []);
+    };
+    PatternsGenerator.prototype.generateVectors = function (_a) {
+        var getNthVector = _a.getNthVector, numberOfVectors = _a.numberOfVectors;
+        return Array(numberOfVectors)
+            .fill(0)
+            .map(function (_, index) { return getNthVector(index); });
+    };
+    PatternsGenerator.prototype.generateCellsPatterns = function (_a) {
+        var _this = this;
+        var board = _a.board, cells = _a.cells, PatternModel = _a.PatternModel;
+        return this.generateStartIndices(cells).reduce(function (patterns, startIndex) {
+            return patterns.concat(_this.generateEndIndices(cells, startIndex).reduce(function (placeablePatterns, endIndex) {
+                var pattern = new PatternModel({
+                    board: board,
+                    cells: cells.slice(startIndex, endIndex + 1),
+                });
+                if (pattern.canBePlaced(_this.config)) {
+                    placeablePatterns.push(pattern);
+                }
+                return placeablePatterns;
+            }, []));
+        }, []);
+    };
+    PatternsGenerator.prototype.generateStartIndices = function (cells) {
+        return Array(cells.length - 1)
+            .fill(0)
+            .map(function (_, startIndex) { return startIndex; })
+            .filter(function (startIndex) { return startIndex === 0 || !cells[startIndex - 1].hasTile(); });
+    };
+    PatternsGenerator.prototype.generateEndIndices = function (cells, startIndex) {
+        return Array(cells.length - startIndex - 1)
+            .fill(0)
+            .map(function (_, endIndex) { return endIndex + startIndex + 1; })
+            .filter(function (endIndex) { return endIndex >= cells.length - 1 || !cells[endIndex + 1].hasTile(); });
+    };
+    return PatternsGenerator;
+}());
+exports["default"] = PatternsGenerator;
 
-/* harmony default export */ __webpack_exports__["default"] = (solve);
 
 /***/ }),
 
-/***/ "efbE":
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+/***/ 19368:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var constants_1 = __webpack_require__(38436);
+var ScoresCalculator = /** @class */ (function () {
+    function ScoresCalculator(config) {
+        var _this = this;
+        this.reduceCellScore = function (_a, cell) {
+            var multiplier = _a.multiplier, score = _a.score;
+            var bonus = _this.config.getCellBonus(cell);
+            var _b = bonus && bonus.canApply(_this.config, cell) ? bonus.value : constants_1.NO_BONUS, characterMultiplier = _b.characterMultiplier, wordMultiplier = _b.wordMultiplier;
+            var characterScore = cell.tile.isBlank ? _this.config.blankScore : _this.config.pointsMap[cell.tile.character];
+            return {
+                multiplier: multiplier * wordMultiplier,
+                score: score + characterScore * characterMultiplier,
+            };
+        };
+        this.config = config;
+    }
+    ScoresCalculator.prototype.calculate = function (pattern) {
+        return this.calculatePatternScoreWithCollisions(pattern) + this.calculateBonusScore(pattern);
+    };
+    ScoresCalculator.prototype.calculateBonusScore = function (pattern) {
+        var areAllTilesUsed = pattern.getNumberOfEmptyCells() === this.config.maximumNumberOfCharacters;
+        return areAllTilesUsed ? this.config.allTilesBonusScore : 0;
+    };
+    ScoresCalculator.prototype.calculatePatternScoreWithCollisions = function (pattern) {
+        var _this = this;
+        return pattern
+            .getCollisions()
+            .reduce(function (patternsScore, collisionPattern) { return patternsScore + _this.calculatePatternScore(collisionPattern); }, this.calculatePatternScore(pattern));
+    };
+    ScoresCalculator.prototype.calculatePatternScore = function (pattern) {
+        var _a = pattern.cells.reduce(this.reduceCellScore, {
+            multiplier: 1,
+            score: 0,
+        }), multiplier = _a.multiplier, score = _a.score;
+        return score * multiplier;
+    };
+    return ScoresCalculator;
+}());
+exports["default"] = ScoresCalculator;
 
-"use strict";
 
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, "a", function() { return /* reexport */ api_getServerLoggingData; });
-__webpack_require__.d(__webpack_exports__, "b", function() { return /* reexport */ api_validateBoard; });
-__webpack_require__.d(__webpack_exports__, "c", function() { return /* reexport */ api_validateCharacters; });
-__webpack_require__.d(__webpack_exports__, "d", function() { return /* reexport */ api_validateConfigId; });
-__webpack_require__.d(__webpack_exports__, "e", function() { return /* reexport */ api_validateLocale; });
-__webpack_require__.d(__webpack_exports__, "f", function() { return /* reexport */ api_validateWord; });
+/***/ }),
+
+/***/ 66650:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-// UNUSED EXPORTS: validateCell, validateCharacter, validateRow, validateTile
 
-// CONCATENATED MODULE: ./src/api/getServerLoggingData.ts
-const getServerLoggingData = request => ({
-  origin: request.headers.origin,
-  referer: request.headers.referer,
-  userAgent: request.headers['user-agent'],
-  xForwardedFor: request.headers['x-forwarded-for'],
-  xRealIp: request.headers['x-real-ip']
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var types_1 = __webpack_require__(46452);
+var uniqBy_1 = __importDefault(__webpack_require__(50285));
+var PatternsFiller_1 = __importDefault(__webpack_require__(6700));
+var PatternsGenerator_1 = __importDefault(__webpack_require__(34196));
+var ScoresCalculator_1 = __importDefault(__webpack_require__(19368));
+var Solver = /** @class */ (function () {
+    function Solver(config, trie) {
+        this.patternsFiller = new PatternsFiller_1.default(config, trie);
+        this.patternsGenerator = new PatternsGenerator_1.default(config);
+        this.scoresCalculator = new ScoresCalculator_1.default(config);
+    }
+    Solver.prototype.solve = function (board, tiles) {
+        var _this = this;
+        var patterns = this.patternsGenerator
+            .generate(board)
+            .reduce(function (filledPatterns, pattern) { return filledPatterns.concat(_this.patternsFiller.fill(pattern, tiles)); }, []);
+        var uniquePatterns = (0, uniqBy_1.default)(patterns, function (pattern) { return JSON.stringify(pattern.toJson()); });
+        var results = uniquePatterns.map(function (pattern, index) {
+            return new types_1.Result({
+                cells: pattern.cells,
+                id: index,
+                numberOfCollisions: pattern.getCollisions().length,
+                points: _this.scoresCalculator.calculate(pattern),
+            });
+        });
+        return results;
+    };
+    return Solver;
+}());
+exports["default"] = Solver;
 
-/* harmony default export */ var api_getServerLoggingData = (getServerLoggingData);
-// EXTERNAL MODULE: external "@scrabble-solver/constants"
-var constants_ = __webpack_require__("h+wf");
 
-// CONCATENATED MODULE: ./src/api/validateCharacter.ts
+/***/ }),
 
+/***/ 40368:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-const validateCharacter = (character, config) => {
-  if (typeof character !== 'string') {
-    throw new Error('character is not a string');
-  }
 
-  if (!config.hasCharacter(character) && character !== constants_["BLANK"]) {
-    throw new Error('character is not valid');
-  }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports["default"] = void 0;
+var Solver_1 = __webpack_require__(66650);
+Object.defineProperty(exports, "default", ({ enumerable: true, get: function () { return __importDefault(Solver_1).default; } }));
 
-/* harmony default export */ var api_validateCharacter = (validateCharacter);
-// CONCATENATED MODULE: ./src/api/validateTile.ts
 
+/***/ }),
 
-const validateTile = (tile, config) => {
-  if (typeof tile !== 'object') {
-    throw new Error('is not an object');
-  }
+/***/ 61704:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-  if (tile !== null) {
-    const {
-      character,
-      isBlank
-    } = tile;
-    api_validateCharacter(character, config);
 
-    if (typeof isBlank !== 'boolean') {
-      throw new Error('isBlank is not a boolean');
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
-  }
 };
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var lib_1 = __webpack_require__(60337);
+var FILE_URL = 'https://raw.githubusercontent.com/HanSolo80/German-Dictionary/master/dictionary.txt';
+var getDeDeWordList = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, (0, lib_1.getTxtWordList)(FILE_URL)];
+    });
+}); };
+exports["default"] = getDeDeWordList;
 
-/* harmony default export */ var api_validateTile = (validateTile);
-// CONCATENATED MODULE: ./src/api/validateCell.ts
 
+/***/ }),
 
-const validateCell = (cell, rowIndex, cellIndex, config) => {
-  if (typeof cell !== 'object') {
-    throw new Error(`board[${rowIndex}][${cellIndex}] is not an object`);
-  }
+/***/ 3284:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-  const {
-    x,
-    y,
-    tile,
-    isEmpty
-  } = cell;
 
-  if (typeof x !== 'number') {
-    throw new Error(`board[${rowIndex}][${cellIndex}].x is not a number`);
-  }
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var lib_1 = __webpack_require__(60337);
+var FILE_URL = 'https://www.wordgamedictionary.com/sowpods/download/sowpods.txt';
+var getEnGbWordList = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, (0, lib_1.getTxtWordList)(FILE_URL)];
+    });
+}); };
+exports["default"] = getEnGbWordList;
 
-  if (x < 0 || x >= config.boardWidth) {
-    throw new Error(`board[${rowIndex}][${cellIndex}].x is out of bounds`);
-  }
 
-  if (typeof y !== 'number') {
-    throw new Error(`board[${rowIndex}][${cellIndex}].y is not a number`);
-  }
+/***/ }),
 
-  if (y < 0 || y >= config.boardHeight) {
-    throw new Error(`board[${rowIndex}][${cellIndex}].y is out of bounds`);
-  }
+/***/ 163:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-  if (typeof isEmpty !== 'boolean') {
-    throw new Error(`board[${rowIndex}][${cellIndex}].isEmpty is not a boolean`);
-  }
 
-  try {
-    api_validateTile(tile, config);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'unknown';
-    throw new Error(`board[${rowIndex}][${cellIndex}].tile ${message}`);
-  }
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var lib_1 = __webpack_require__(60337);
+var FILE_URL = 'https://www.wordgamedictionary.com/twl06/download/twl06.txt';
+var getEnUsWordList = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, (0, lib_1.getTxtWordList)(FILE_URL)];
+    });
+}); };
+exports["default"] = getEnUsWordList;
 
-/* harmony default export */ var api_validateCell = (validateCell);
-// CONCATENATED MODULE: ./src/api/validateRow.ts
 
+/***/ }),
 
-const validateRow = (row, rowIndex, config) => {
-  if (!Array.isArray(row)) {
-    throw new Error(`board[${rowIndex}] is not an array`);
-  }
+/***/ 87537:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-  if (row.length !== config.boardWidth) {
-    throw new Error(`board[${rowIndex}] does not have ${config.boardWidth} cells`);
-  }
 
-  row.forEach((cell, cellIndex) => api_validateCell(cell, rowIndex, cellIndex, config));
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var lib_1 = __webpack_require__(60337);
+var FILE_URL = 'https://raw.githubusercontent.com/kamilmielnik/fise-2/master/fise-2.txt';
+var getEsEsWordList = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var words;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, lib_1.getTxtWordList)(FILE_URL)];
+            case 1:
+                words = _a.sent();
+                return [2 /*return*/, words.map(normalizeWord)];
+        }
+    });
+}); };
+var normalizeWord = function (word) {
+    // normalization from https://stackoverflow.com/a/37511463
+    return word.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+};
+exports["default"] = getEsEsWordList;
 
-/* harmony default export */ var api_validateRow = (validateRow);
-// CONCATENATED MODULE: ./src/api/validateBoard.ts
 
+/***/ }),
 
-const validateBoard = (board, config) => {
-  if (!Array.isArray(board)) {
-    throw new Error('Invalid "board" parameter: not an array');
-  }
+/***/ 27098:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-  if (board.length !== config.boardHeight) {
-    throw new Error(`Invalid "board" parameter: does not have ${config.boardHeight} rows`);
-  }
 
-  try {
-    board.forEach((row, rowIndex) => api_validateRow(row, rowIndex, config));
-    validateTwoCharacterTiles(board, config);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'unknown';
-    throw new Error(`Invalid "board" parameter: ${message}`);
-  }
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var lib_1 = __webpack_require__(60337);
+var FILE_URL = 'https://raw.githubusercontent.com/hbenbel/French-Dictionary/a573eab10cc798d7d5da7daab4d2ac0259bb46a3/dictionary/dictionary.txt';
+var getFrFrWordList = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var words;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, lib_1.getTxtWordList)(FILE_URL)];
+            case 1:
+                words = _a.sent();
+                return [2 /*return*/, words.map(normalizeWord)];
+        }
+    });
+}); };
+var normalizeWord = function (word) {
+    // normalization from https://stackoverflow.com/a/37511463
+    return word.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+};
+exports["default"] = getFrFrWordList;
 
-const validateTwoCharacterTiles = (board, config) => {
-  const cells = board.flat().filter(cell => cell.tile && config.isTwoCharacterTilePrefix(cell.tile.character));
 
-  for (const cell of cells) {
-    for (const characters of config.twoCharacterTiles) {
-      const canCheckDown = cell.y + 1 < board.length;
-      const canCheckRight = cell.x + 1 < board[0].length;
-      const cellDown = board[cell.y + 1][cell.x];
-      const cellRight = board[cell.y][cell.x + 1];
-      const collidesDown = canCheckDown && cellDown.tile && cellDown.tile.character === characters[1];
-      const collidesRight = canCheckRight && cellRight.tile && cellRight.tile.character === characters[1];
-      const collides = collidesDown || collidesRight;
+/***/ }),
 
-      if (cell.tile && characters.startsWith(cell.tile.character) && collides) {
-        throw new Error(`${characters} can only be used as a single tile`);
-      }
+/***/ 81848:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var cheerio_1 = __importDefault(__webpack_require__(55473));
+var memfs_1 = __webpack_require__(28098);
+var unzipper_1 = __importDefault(__webpack_require__(23428));
+var url_1 = __webpack_require__(57310);
+var lib_1 = __webpack_require__(60337);
+var PAGE_URL = 'https://sjp.pl/sl/growy/';
+var FILE_TO_EXTRACT_FROM_ZIP = 'slowa.txt';
+var getPlPlWordList = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var zipTempFilename, tempFilename, zipUrl, file, words;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                zipTempFilename = (0, lib_1.getTempFilename)();
+                tempFilename = (0, lib_1.getTempFilename)();
+                return [4 /*yield*/, fetchZipUrl(PAGE_URL)];
+            case 1:
+                zipUrl = _a.sent();
+                return [4 /*yield*/, (0, lib_1.downloadFile)(zipUrl, memfs_1.fs.createWriteStream(zipTempFilename))];
+            case 2:
+                _a.sent();
+                return [4 /*yield*/, unzip(zipTempFilename, tempFilename)];
+            case 3:
+                _a.sent();
+                memfs_1.fs.unlinkSync(zipTempFilename);
+                file = memfs_1.fs.readFileSync(tempFilename, 'utf-8');
+                memfs_1.fs.unlinkSync(tempFilename);
+                words = (0, lib_1.extractWords)(file.toString());
+                return [2 /*return*/, words];
+        }
+    });
+}); };
+var fetchZipUrl = function (url) { return __awaiter(void 0, void 0, void 0, function () {
+    var html, filename, href;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, lib_1.downloadHtml)(url)];
+            case 1:
+                html = _a.sent();
+                return [4 /*yield*/, parseZipContainingPage(html)];
+            case 2:
+                filename = _a.sent();
+                href = new url_1.URL(filename, url).href;
+                return [2 /*return*/, href];
+        }
+    });
+}); };
+var parseZipContainingPage = function (html) {
+    var $ = cheerio_1.default.load(html);
+    var $links = $('a');
+    var links = Array.from($links)
+        .map(function (link) { return $(link).attr('href'); })
+        .filter(Boolean);
+    var zipFilename = links.find(function (link) { return link.endsWith('.zip'); });
+    if (typeof zipFilename === 'undefined') {
+        throw new Error('Cannot find link to zip file on the page');
     }
-  }
+    return zipFilename;
+};
+var unzip = function (zipFilename, outputFilename) {
+    return memfs_1.fs
+        .createReadStream(zipFilename)
+        .pipe(unzipper_1.default.Parse())
+        .on('entry', function (entry) {
+        var fileName = entry.path;
+        if (fileName === FILE_TO_EXTRACT_FROM_ZIP) {
+            entry.pipe(memfs_1.fs.createWriteStream(outputFilename));
+        }
+        else {
+            entry.autodrain();
+        }
+    })
+        .promise();
 };
+exports["default"] = getPlPlWordList;
 
-/* harmony default export */ var api_validateBoard = (validateBoard);
-// CONCATENATED MODULE: ./src/api/validateCharacters.ts
 
+/***/ }),
 
-const validateCharacters = (characters, config) => {
-  if (!Array.isArray(characters)) {
-    throw new Error('Invalid "characters" parameter: not an array');
-  }
+/***/ 8769:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-  if (characters.length === 0) {
-    throw new Error('Invalid "characters" parameter: empty array');
-  }
 
-  characters.forEach((character, characterIndex) => {
-    try {
-      api_validateCharacter(character, config);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'unknown';
-      throw new Error(`Invalid "characters" parameter: characters[${characterIndex}] ${message}`);
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var types_1 = __webpack_require__(46452);
+var getDeDeWordList_1 = __importDefault(__webpack_require__(61704));
+var getEnGbWordList_1 = __importDefault(__webpack_require__(3284));
+var getEnUsWordList_1 = __importDefault(__webpack_require__(163));
+var getEsEsWordList_1 = __importDefault(__webpack_require__(87537));
+var getFrFrWordList_1 = __importDefault(__webpack_require__(27098));
+var getPlPlWordList_1 = __importDefault(__webpack_require__(81848));
+var localeMap = (_a = {},
+    _a[types_1.Locale.DE_DE] = getDeDeWordList_1.default,
+    _a[types_1.Locale.EN_GB] = getEnGbWordList_1.default,
+    _a[types_1.Locale.EN_US] = getEnUsWordList_1.default,
+    _a[types_1.Locale.ES_ES] = getEsEsWordList_1.default,
+    _a[types_1.Locale.FR_FR] = getFrFrWordList_1.default,
+    _a[types_1.Locale.PL_PL] = getPlPlWordList_1.default,
+    _a);
+var getWordList = function (locale) { return localeMap[locale](); };
+exports["default"] = getWordList;
+
+
+/***/ }),
+
+/***/ 51585:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-  });
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getWordList = exports.getDeDeWordList = exports.getPlPlWordList = exports.getFrFrWordList = exports.getEnGbWordList = exports.getEnUsWordList = void 0;
+var getEnUsWordList_1 = __webpack_require__(163);
+Object.defineProperty(exports, "getEnUsWordList", ({ enumerable: true, get: function () { return __importDefault(getEnUsWordList_1).default; } }));
+var getEnGbWordList_1 = __webpack_require__(3284);
+Object.defineProperty(exports, "getEnGbWordList", ({ enumerable: true, get: function () { return __importDefault(getEnGbWordList_1).default; } }));
+var getFrFrWordList_1 = __webpack_require__(27098);
+Object.defineProperty(exports, "getFrFrWordList", ({ enumerable: true, get: function () { return __importDefault(getFrFrWordList_1).default; } }));
+var getPlPlWordList_1 = __webpack_require__(81848);
+Object.defineProperty(exports, "getPlPlWordList", ({ enumerable: true, get: function () { return __importDefault(getPlPlWordList_1).default; } }));
+var getDeDeWordList_1 = __webpack_require__(61704);
+Object.defineProperty(exports, "getDeDeWordList", ({ enumerable: true, get: function () { return __importDefault(getDeDeWordList_1).default; } }));
+var getWordList_1 = __webpack_require__(8769);
+Object.defineProperty(exports, "getWordList", ({ enumerable: true, get: function () { return __importDefault(getWordList_1).default; } }));
+__exportStar(__webpack_require__(60337), exports);
+
+
+/***/ }),
+
+/***/ 920:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var follow_redirects_1 = __webpack_require__(24396);
+var downloadFile = function (url, outputStream) {
+    return new Promise(function (resolve, reject) {
+        var protocol = url.startsWith('https') ? follow_redirects_1.https : follow_redirects_1.http;
+        var request = protocol.get(url, function (response) {
+            if (typeof response.statusCode === 'undefined' || response.statusCode >= 400) {
+                reject();
+                return;
+            }
+            response.pipe(outputStream);
+            response.on('error', reject);
+            response.on('end', resolve);
+        });
+        request.on('error', reject);
+    });
+};
+exports["default"] = downloadFile;
+
+
+/***/ }),
 
-/* harmony default export */ var api_validateCharacters = (validateCharacters);
-// EXTERNAL MODULE: external "@scrabble-solver/configs"
-var configs_ = __webpack_require__("DiT0");
+/***/ 78015:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var follow_redirects_1 = __webpack_require__(24396);
+var downloadHtml = function (url) {
+    return new Promise(function (resolve, reject) {
+        var protocol = url.startsWith('https') ? follow_redirects_1.https : follow_redirects_1.http;
+        protocol.get(url, function (response) {
+            var data = '';
+            response.setEncoding('utf8');
+            response.on('data', function (chunk) {
+                data += chunk;
+            });
+            response.on('end', function () {
+                resolve(data);
+            });
+            response.on('error', reject);
+        });
+    });
+};
+exports["default"] = downloadHtml;
+
+
+/***/ }),
 
-// CONCATENATED MODULE: ./src/api/validateConfigId.ts
+/***/ 39759:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 
-const validateConfigId = configId => {
-  if (!Object(configs_["isConfigId"])(configId)) {
-    throw new Error('Invalid "configId" parameter');
-  }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var findFirstWordIndex_1 = __importDefault(__webpack_require__(47669));
+var extractWords = function (file) {
+    var lines = file.replace(/\r/g, '').split('\n');
+    var firstWordIndex = (0, findFirstWordIndex_1.default)(lines);
+    var words = lines.slice(firstWordIndex).filter(Boolean);
+    return words;
+};
+exports["default"] = extractWords;
 
-/* harmony default export */ var api_validateConfigId = (validateConfigId);
-// EXTERNAL MODULE: external "@scrabble-solver/types"
-var types_ = __webpack_require__("E2kR");
 
-// CONCATENATED MODULE: ./src/api/validateLocale.ts
+/***/ }),
 
-const locales = Object.values(types_["Locale"]);
+/***/ 47669:
+/***/ ((__unused_webpack_module, exports) => {
 
-const validateLocale = locale => {
-  if (typeof locale !== 'string') {
-    throw new Error('Invalid "locale" parameter: not a string');
-  }
 
-  if (!locales.includes(locale)) {
-    throw new Error(`Invalid "locale" parameter: must be one of: ${locales.join(', ')}`);
-  }
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var findFirstWordIndex = function (lines) {
+    var firstWordIndex = lines.findIndex(function (line, index) {
+        var nextLine = line[index + 1] || '';
+        var isNextLineInOrder = line.localeCompare(nextLine) === 1;
+        var hasWhitespace = Boolean(line.match(/\s/));
+        var 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["default"] = findFirstWordIndex;
+
+
+/***/ }),
+
+/***/ 93938:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-/* harmony default export */ var api_validateLocale = (validateLocale);
-// CONCATENATED MODULE: ./src/api/validateWord.ts
-const validateWord = word => {
-  if (typeof word !== 'string') {
-    throw new Error('"word" is not a string');
-  }
 
-  if (word.length === 0) {
-    throw new Error('"word" is an empty string');
-  }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var crypto_1 = __importDefault(__webpack_require__(6113));
+var getHash = function (bytes) {
+    if (bytes === void 0) { bytes = 8; }
+    return crypto_1.default.randomBytes(bytes).toString('hex');
+};
+exports["default"] = getHash;
 
-/* harmony default export */ var api_validateWord = (validateWord);
-// CONCATENATED MODULE: ./src/api/index.ts
 
+/***/ }),
 
+/***/ 52688:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var getHash_1 = __importDefault(__webpack_require__(93938));
+var getTempFilename = function () {
+    return "/".concat((0, getHash_1.default)(), ".txt");
+};
+exports["default"] = getTempFilename;
 
 
+/***/ }),
 
+/***/ 78029:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var memfs_1 = __webpack_require__(28098);
+var downloadFile_1 = __importDefault(__webpack_require__(920));
+var extractWords_1 = __importDefault(__webpack_require__(39759));
+var getTempFilename_1 = __importDefault(__webpack_require__(52688));
+var getTxtWordList = function (url) { return __awaiter(void 0, void 0, void 0, function () {
+    var tempFilename, file, words;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                tempFilename = (0, getTempFilename_1.default)();
+                return [4 /*yield*/, (0, downloadFile_1.default)(url, memfs_1.fs.createWriteStream(tempFilename))];
+            case 1:
+                _a.sent();
+                file = memfs_1.fs.readFileSync(tempFilename, 'utf-8');
+                words = (0, extractWords_1.default)(file.toString());
+                memfs_1.fs.unlinkSync(tempFilename);
+                return [2 /*return*/, words];
+        }
+    });
+}); };
+exports["default"] = getTxtWordList;
 
 
 /***/ }),
 
-/***/ "h+wf":
-/***/ (function(module, exports) {
+/***/ 60337:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getTxtWordList = exports.getTempFilename = exports.getHash = exports.findFirstWordIndex = exports.extractWords = exports.downloadHtml = exports.downloadFile = void 0;
+var downloadFile_1 = __webpack_require__(920);
+Object.defineProperty(exports, "downloadFile", ({ enumerable: true, get: function () { return __importDefault(downloadFile_1).default; } }));
+var downloadHtml_1 = __webpack_require__(78015);
+Object.defineProperty(exports, "downloadHtml", ({ enumerable: true, get: function () { return __importDefault(downloadHtml_1).default; } }));
+var extractWords_1 = __webpack_require__(39759);
+Object.defineProperty(exports, "extractWords", ({ enumerable: true, get: function () { return __importDefault(extractWords_1).default; } }));
+var findFirstWordIndex_1 = __webpack_require__(47669);
+Object.defineProperty(exports, "findFirstWordIndex", ({ enumerable: true, get: function () { return __importDefault(findFirstWordIndex_1).default; } }));
+var getHash_1 = __webpack_require__(93938);
+Object.defineProperty(exports, "getHash", ({ enumerable: true, get: function () { return __importDefault(getHash_1).default; } }));
+var getTempFilename_1 = __webpack_require__(52688);
+Object.defineProperty(exports, "getTempFilename", ({ enumerable: true, get: function () { return __importDefault(getTempFilename_1).default; } }));
+var getTxtWordList_1 = __webpack_require__(78029);
+Object.defineProperty(exports, "getTxtWordList", ({ enumerable: true, get: function () { return __importDefault(getTxtWordList_1).default; } }));
 
-module.exports = require("@scrabble-solver/constants");
 
 /***/ })
 
-/******/ });
+};
+;
+
+// load runtime
+var __webpack_require__ = require("../../webpack-api-runtime.js");
+__webpack_require__.C(exports);
+var __webpack_exec__ = (moduleId) => (__webpack_require__(__webpack_require__.s = moduleId))
+var __webpack_exports__ = __webpack_require__.X(0, [50,206,907], () => (__webpack_exec__(38104)));
+module.exports = __webpack_exports__;
+
+})();