@scrabble-solver/scrabble-solver 2.16.7 → 2.18.0

package/src/solver-worker/getGaddag.test.ts

@@ -0,0 +1,109 @@
+import { Gaddag } from '@kamilmielnik/gaddag';
+import { Locale } from '@scrabble-solver/types';
+import { describe, expect, it, mock } from 'bun:test';
+
+import type * as getGaddagModule from './getGaddag';
+
+let dictionary: Response | undefined;
+const deletedLocales: Locale[] = [];
+
+await mock.module('./dictionaries', () => ({
+  deleteDictionary: (locale: Locale) => {
+    deletedLocales.push(locale);
+    return Promise.resolve();
+  },
+  getDictionary: () => Promise.resolve(dictionary),
+}));
+
+const { getGaddag }: typeof getGaddagModule = await import('./getGaddag');
+
+describe('getGaddag', () => {
+  it('returns undefined when there is no cached dictionary', async () => {
+    dictionary = undefined;
+    expect(await getGaddag(Locale.EN_US)).toBeUndefined();
+  });
+
+  it('deserializes a cached dictionary', async () => {
+    dictionary = createDictionary(['scrabble', 'solver']);
+    const gaddag = await getGaddag(Locale.EN_US);
+
+    expect(gaddag?.has('scrabble')).toBe(true);
+    expect(gaddag?.has('trie')).toBe(false);
+  });
+
+  it('deletes a dictionary cached by an app version with an incompatible format', async () => {
+    dictionary = new Response('serialized trie from a previous app version');
+
+    expect(await getGaddag(Locale.PL_PL)).toBeUndefined();
+    expect(deletedLocales).toContain(Locale.PL_PL);
+  });
+
+  it('deletes a corrupted dictionary', async () => {
+    dictionary = new Response(Gaddag.fromArray(['scrabble']).serialize().subarray(0, 10));
+
+    expect(await getGaddag(Locale.FA_IR)).toBeUndefined();
+    expect(deletedLocales).toContain(Locale.FA_IR);
+  });
+
+  it('reuses the deserialized dictionary while the cached response is unchanged', async () => {
+    dictionary = createDictionary(['scrabble'], { etag: '"v1"' });
+    const first = await getGaddag(Locale.EN_GB);
+    dictionary = createDictionary(['scrabble'], { etag: '"v1"' });
+    const second = await getGaddag(Locale.EN_GB);
+
+    expect(first?.has('scrabble')).toBe(true);
+    expect(second).toBe(first);
+  });
+
+  it('reuses the deserialized dictionary when a revalidation only refreshes the Date header', async () => {
+    dictionary = createDictionary(['scrabble'], { date: 'Thu, 06 Aug 2026 00:00:00 GMT', etag: '"v1"' });
+    const first = await getGaddag(Locale.FR_FR);
+    dictionary = createDictionary(['scrabble'], { date: 'Fri, 07 Aug 2026 00:00:00 GMT', etag: '"v1"' });
+    const second = await getGaddag(Locale.FR_FR);
+
+    expect(first?.has('scrabble')).toBe(true);
+    expect(second).toBe(first);
+  });
+
+  it('picks up a dictionary another tab wrote into the shared cache', async () => {
+    dictionary = createDictionary(['scrabble'], { etag: '"v1"' });
+    const first = await getGaddag(Locale.TR_TR);
+    dictionary = createDictionary(['solver'], { etag: '"v2"' });
+    const second = await getGaddag(Locale.TR_TR);
+
+    expect(first?.has('scrabble')).toBe(true);
+    expect(second).not.toBe(first);
+    expect(second?.has('solver')).toBe(true);
+  });
+
+  it('falls back to the Date header for responses without an ETag', async () => {
+    dictionary = createDictionary(['scrabble'], { date: 'Thu, 06 Aug 2026 00:00:00 GMT' });
+    const first = await getGaddag(Locale.DE_DE);
+    dictionary = createDictionary(['scrabble'], { date: 'Thu, 06 Aug 2026 00:00:00 GMT' });
+    const second = await getGaddag(Locale.DE_DE);
+    dictionary = createDictionary(['scrabble'], { date: 'Fri, 07 Aug 2026 00:00:00 GMT' });
+    const third = await getGaddag(Locale.DE_DE);
+
+    expect(first?.has('scrabble')).toBe(true);
+    expect(second).toBe(first);
+    expect(third).not.toBe(first);
+    expect(third?.has('scrabble')).toBe(true);
+  });
+
+  it('memoizes each locale independently', async () => {
+    dictionary = createDictionary(['scrabble'], { etag: '"es"' });
+    const spanish = await getGaddag(Locale.ES_ES);
+    dictionary = createDictionary(['solver'], { etag: '"ro"' });
+    const romanian = await getGaddag(Locale.RO_RO);
+    dictionary = createDictionary(['scrabble'], { etag: '"es"' });
+    const spanishAgain = await getGaddag(Locale.ES_ES);
+
+    expect(spanish?.has('scrabble')).toBe(true);
+    expect(romanian?.has('solver')).toBe(true);
+    expect(spanishAgain).toBe(spanish);
+  });
+});
+
+function createDictionary(words: string[], headers: Record<string, string> = {}): Response {
+  return new Response(Gaddag.fromArray(words).serialize(), { headers });
+}

package/src/solver-worker/getGaddag.ts

@@ -0,0 +1,62 @@
+import { Gaddag } from '@kamilmielnik/gaddag';
+import { type Locale } from '@scrabble-solver/types';
+
+import { deleteDictionary, getDictionary } from './dictionaries';
+
+interface DeserializedDictionary {
+  gaddag: Gaddag;
+  version: string;
+}
+
+const deserializedDictionaries: Partial<Record<Locale, DeserializedDictionary>> = {};
+
+/**
+ * Returns undefined when there is no cached dictionary or when the cached
+ * dictionary cannot be deserialized (it was downloaded by an app version with
+ * an incompatible format). An undeserializable entry is deleted before
+ * returning, so the revalidation the caller triggers next downloads a fresh
+ * dictionary instead of getting a 304 for the broken bytes.
+ */
+export async function getGaddag(locale: Locale): Promise<Gaddag | undefined> {
+  const response = await getDictionary(locale);
+
+  if (typeof response === 'undefined') {
+    return undefined;
+  }
+
+  const version = readVersion(response);
+  const deserialized = deserializedDictionaries[locale];
+
+  if (deserialized && deserialized.version === version) {
+    return deserialized.gaddag;
+  }
+
+  try {
+    const gaddag = Gaddag.deserialize(new Uint8Array(await response.arrayBuffer()));
+
+    if (typeof version !== 'undefined') {
+      deserializedDictionaries[locale] = { gaddag, version };
+    }
+
+    return gaddag;
+  } catch {
+    delete deserializedDictionaries[locale];
+    await deleteDictionary(locale);
+    return undefined;
+  }
+}
+
+/**
+ * Read from the cached response rather than tracked in memory, so a dictionary
+ * another tab downloaded into the shared cache is picked up here too.
+ */
+function readVersion(response: Response): string | undefined {
+  const etag = response.headers.get('etag');
+
+  if (etag !== null) {
+    return etag;
+  }
+
+  const parts = ['date', 'content-length'].map((name) => response.headers.get(name) ?? '');
+  return parts.every((part) => part === '') ? undefined : parts.join('|');
+}

package/src/solver-worker/index.ts

@@ -0,0 +1 @@
+export { prefetchDictionary, solveLocally, verifyLocally } from './client';

package/src/solver-worker/index.worker.ts

@@ -0,0 +1,124 @@
+/// <reference lib="WebWorker" />
+
+import { getConfig } from '@scrabble-solver/configs';
+import { BLANK } from '@scrabble-solver/constants';
+import { solve } from '@scrabble-solver/solver';
+import { Board, type Locale, Tile } from '@scrabble-solver/types';
+
+import { type SolveRequestPayload, type VerifyRequestPayload } from '@/types';
+
+import { revalidateDictionary } from './dictionaries';
+import { getGaddag } from './getGaddag';
+import { type SolverWorkerRequest, type SolverWorkerResponse } from './messages';
+
+declare const self: DedicatedWorkerGlobalScope;
+
+/**
+ * Solves run synchronously on the single worker thread, so a burst of requests
+ * would queue stale solves ahead of the latest one.
+ */
+let latestSolveId = 0;
+
+self.addEventListener('message', ({ data }: MessageEvent<SolverWorkerRequest>) => {
+  if (data.type === 'solve') {
+    latestSolveId = data.id;
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    respond(data.id, () => handleSolve(data.id, data.payload));
+  } else if (data.type === 'verify') {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    respond(data.id, () => handleVerify(data.id, data.payload));
+  } else if (data.type === 'prefetch') {
+    prefetchDictionary(data.locale).catch(() => undefined);
+  }
+});
+
+async function handleSolve(id: number, payload: SolveRequestPayload): Promise<SolverWorkerResponse> {
+  const { board, characters, game, locale } = payload;
+  const gaddag = await getGaddag(locale);
+  revalidateInBackground(locale);
+
+  if (!gaddag) {
+    return { id, outcome: 'unavailable' };
+  }
+
+  await yieldToQueuedMessages();
+
+  if (latestSolveId !== id) {
+    return { id, outcome: 'superseded' };
+  }
+
+  const config = getConfig(game, locale);
+  const tiles = characters.map((character) => new Tile({ character, isBlank: character === BLANK }));
+  return { data: solve(gaddag, config, Board.fromJson(board), tiles), id, outcome: 'answered' };
+}
+
+async function handleVerify(
+  id: number,
+  { board: boardJson, locale }: VerifyRequestPayload,
+): Promise<SolverWorkerResponse> {
+  const gaddag = await getGaddag(locale);
+  revalidateInBackground(locale);
+
+  if (!gaddag) {
+    return { id, outcome: 'unavailable' };
+  }
+
+  const board = Board.fromJson(boardJson);
+  const words = board.getWords().sort((a, b) => a.localeCompare(b, locale));
+  const invalidWords: string[] = [];
+  const validWords: string[] = [];
+
+  for (const word of words) {
+    if (gaddag.has(word)) {
+      validWords.push(word);
+    } else {
+      invalidWords.push(word);
+    }
+  }
+
+  return { data: { invalidWords, validWords }, id, outcome: 'answered' };
+}
+
+/**
+ * Deserializes the dictionary ahead of the first solve, so it does not pay the
+ * cold-start cost. Warms even when revalidation fails (e.g. offline) - a
+ * previously cached dictionary can still be deserialized.
+ */
+async function prefetchDictionary(locale: Locale): Promise<void> {
+  try {
+    await revalidateDictionary(locale);
+  } catch {
+    // Solving falls back to the server until a later revalidation succeeds.
+  }
+
+  await getGaddag(locale);
+}
+
+/**
+ * Revalidation failures are expected (offline, server down) and must not
+ * surface as unhandled rejections - solving keeps using the cached dictionary
+ * until a later revalidation succeeds.
+ */
+function revalidateInBackground(locale: Locale): void {
+  revalidateDictionary(locale).catch(() => undefined);
+}
+
+async function respond(id: number, handle: () => Promise<SolverWorkerResponse>): Promise<void> {
+  try {
+    self.postMessage(await handle());
+  } catch {
+    self.postMessage({ id, outcome: 'unavailable' } satisfies SolverWorkerResponse);
+  }
+}
+
+/**
+ * Messages queued behind this handler dispatch only between macrotasks - a
+ * MessageChannel round-trip lets them register before an expensive solve.
+ */
+function yieldToQueuedMessages(): Promise<void> {
+  return new Promise((resolve) => {
+    const { port1, port2 } = new MessageChannel();
+    port1.onmessage = () => resolve();
+    port2.postMessage(null);
+  });
+}

package/src/solver-worker/messages.ts

@@ -0,0 +1,20 @@
+import { type Locale, type ResultJson } from '@scrabble-solver/types';
+
+import { type SolveRequestPayload, type VerifyRequestPayload } from '@/types';
+
+export interface VerifyResult {
+  invalidWords: string[];
+  validWords: string[];
+}
+
+export type SolverWorkerRequest =
+  | { id: number; type: 'prefetch'; locale: Locale }
+  | { id: number; type: 'solve'; payload: SolveRequestPayload }
+  | { id: number; type: 'verify'; payload: VerifyRequestPayload };
+
+export type SolverWorkerResponse =
+  | { id: number; outcome: 'answered'; data: ResultJson[] | VerifyResult }
+  /** No cached dictionary, or an internal error - the caller falls back to the server. */
+  | { id: number; outcome: 'unavailable' }
+  /** A newer solve replaced this one - the newer answer is the one worth waiting for. */
+  | { id: number; outcome: 'superseded' };

package/src/state/actions.ts

@@ -1,5 +1,5 @@
 import { createAction } from '@reduxjs/toolkit';
 
-export const initialize = createAction('initialize');
+export const initialize = createAction<{ version: string }>('initialize');
 
 export const reset = createAction('reset');

package/src/state/app/index.ts

@@ -0,0 +1,4 @@
+export * from './initialState';
+export * from './selectors';
+export * from './slice';
+export * from './types';

package/src/state/app/initialState.ts

@@ -0,0 +1,6 @@
+import type { AppState } from './types';
+
+export const appInitialState: AppState = {
+  isHydrated: false,
+  version: '',
+};

package/src/state/app/selectors.ts

@@ -0,0 +1,5 @@
+import type { RootState } from '../types';
+
+export const selectIsHydrated = (state: RootState): boolean => state.app.isHydrated;
+
+export const selectVersion = (state: RootState): string => state.app.version;

package/src/state/app/slice.ts

@@ -0,0 +1,20 @@
+import { createSlice } from '@reduxjs/toolkit';
+
+import { initialize } from '../actions';
+
+import { appInitialState } from './initialState';
+
+export const appSlice = createSlice({
+  initialState: appInitialState,
+  name: 'app',
+  reducers: {
+    hydrated: (state) => {
+      state.isHydrated = true;
+    },
+  },
+  extraReducers: (builder) => {
+    builder.addCase(initialize, (state, action) => {
+      state.version = action.payload.version;
+    });
+  },
+});

package/src/state/app/types.ts

@@ -0,0 +1,4 @@
+export interface AppState {
+  isHydrated: boolean;
+  version: string;
+}

package/src/state/board/initialState.ts

@@ -1,7 +1,6 @@
 import { getConfig } from '@scrabble-solver/configs';
 import { Board } from '@scrabble-solver/types';
 
-import { localStorage } from '../localStorage';
 import { settingsInitialState } from '../settings';
 
 import type { BoardState } from './types';
@@ -9,7 +8,7 @@ import type { BoardState } from './types';
 const { game, locale } = settingsInitialState;
 const { boardHeight, boardWidth } = getConfig(game, locale);
 
-export const boardInitialState: BoardState = localStorage.getBoard() ?? Board.create(boardWidth, boardHeight);
+export const boardInitialState: BoardState = Board.create(boardWidth, boardHeight);
 
 // const createOxyphenbutazone = () => {
 //   // Tiles: oypbaze

package/src/state/i18n/index.ts

@@ -0,0 +1,4 @@
+export * from './initialState';
+export * from './selectors';
+export * from './slice';
+export * from './types';

package/src/state/i18n/initialState.ts

@@ -0,0 +1,5 @@
+import type { I18nState } from './types';
+
+export const i18nInitialState: I18nState = {
+  translations: {},
+};

package/src/state/i18n/selectors.ts

@@ -0,0 +1,3 @@
+import type { RootState } from '../types';
+
+export const selectLoadedTranslations = (state: RootState) => state.i18n.translations;

package/src/state/i18n/slice.ts

@@ -0,0 +1,16 @@
+import { createSlice, type PayloadAction } from '@reduxjs/toolkit';
+import { type Locale } from '@scrabble-solver/types';
+
+import type { Translations } from '@/types';
+
+import { i18nInitialState } from './initialState';
+
+export const i18nSlice = createSlice({
+  initialState: i18nInitialState,
+  name: 'i18n',
+  reducers: {
+    loaded: (state, action: PayloadAction<{ locale: Locale; translations: Translations }>) => {
+      state.translations[action.payload.locale] = action.payload.translations;
+    },
+  },
+});

package/src/state/i18n/types.ts

@@ -0,0 +1,7 @@
+import { type Locale } from '@scrabble-solver/types';
+
+import type { Translations } from '@/types';
+
+export interface I18nState {
+  translations: Partial<Record<Locale, Translations>>;
+}

package/src/state/index.ts

@@ -1,8 +1,10 @@
 export * from './actions';
+export * from './app';
 export * from './board';
 export * from './cellFilters';
 export * from './dictionary';
 export * from './hoveredTile';
+export * from './i18n';
 export * from './localStorage';
 export * from './rack';
 export * from './results';
@@ -12,4 +14,5 @@ export * from './solve';
 export * from './store';
 export * from './useTranslate';
 export * from './useTypedSelector';
+export * from './useTypedStore';
 export * from './verify';

package/src/state/lib.ts

@@ -1,7 +1,7 @@
 import { BLANK } from '@scrabble-solver/constants';
 import { type Board, type Config } from '@scrabble-solver/types';
 
-import { createKeyComparator } from '@/lib';
+import { createKeyComparator } from '@/lib/createKeyComparator';
 import { type RemainingTile } from '@/types';
 
 export const getRemainingTiles = (

package/src/state/localStorage.ts

@@ -1,13 +1,20 @@
-import { Board, type BoardJson } from '@scrabble-solver/types';
+import { Board, type BoardJson, isObject, type Locale } from '@scrabble-solver/types';
 import store2 from 'store2';
 
-import type { Rack } from '@/types';
+import type { Rack, Translations } from '@/types';
 
 import type { SettingsState } from './settings/types';
 
 const BOARD = 'board';
 const RACK = 'rack';
 const SETTINGS = 'settings';
+const TRANSLATIONS = 'translations';
+
+interface PersistedTranslations {
+  locale: Locale;
+  translations: Translations;
+  version: string;
+}
 
 const LEGACY_KEYS: Record<keyof SettingsState, string> = {
   autoGroupTiles: 'auto-group-tiles',
@@ -21,33 +28,15 @@ const LEGACY_KEYS: Record<keyof SettingsState, string> = {
 
 const store = store2.namespace('scrabble-solver');
 
-/**
- * Introduced in 2.15.26 on 2026/04/27.
- * Life expectancy: 1y.
- */
-const migrateLegacySettings = (): Partial<SettingsState> => {
-  const settings: Partial<SettingsState> = {};
-  let hasLegacy = false;
-
-  for (const [setting, legacyKey] of Object.entries(LEGACY_KEYS) as [keyof SettingsState, string][]) {
-    if (store.has(legacyKey)) {
-      settings[setting] = store.get(legacyKey);
-      store.remove(legacyKey);
-      hasLegacy = true;
-    }
-  }
-
-  if (hasLegacy) {
-    store.set(SETTINGS, settings, true);
-  }
-
-  return settings;
-};
-
 export const localStorage = {
   getBoard(): Board | undefined {
-    const serialized = store.get(BOARD) as string | undefined;
-    return serialized ? Board.fromJson(JSON.parse(serialized) as BoardJson) : undefined;
+    try {
+      const serialized = store.get(BOARD) as string | undefined;
+      return serialized ? Board.fromJson(JSON.parse(serialized) as BoardJson) : undefined;
+    } catch {
+      store.remove(BOARD);
+      return undefined;
+    }
   },
 
   setBoard(board: Board | undefined): void {
@@ -56,7 +45,14 @@ export const localStorage = {
   },
 
   getRack(): Rack | undefined {
-    return store.get(RACK) as Rack | undefined;
+    const rack = store.get(RACK) as Rack | undefined;
+
+    if (rack !== undefined && !Array.isArray(rack)) {
+      store.remove(RACK);
+      return undefined;
+    }
+
+    return rack;
   },
 
   setRack(rack: Rack | undefined): void {
@@ -65,10 +61,71 @@ export const localStorage = {
 
   getSettings(): Partial<SettingsState> {
     const stored = store.get(SETTINGS) as Partial<SettingsState> | undefined;
-    return stored ?? migrateLegacySettings();
+
+    if (stored !== undefined && !isObject(stored)) {
+      store.remove(SETTINGS);
+    }
+
+    return migrateHiddenShowCoordinates(isObject(stored) ? stored : migrateLegacySettings());
   },
 
   setSettings(settings: SettingsState): void {
     store.set(SETTINGS, settings, true);
   },
+
+  getTranslations(locale: Locale, version: string): Translations | undefined {
+    const stored = store.get(TRANSLATIONS) as PersistedTranslations | undefined;
+
+    if (typeof stored === 'undefined') {
+      return undefined;
+    }
+
+    if (!isObject(stored) || stored.locale !== locale || stored.version !== version || !isObject(stored.translations)) {
+      store.remove(TRANSLATIONS);
+      return undefined;
+    }
+
+    return stored.translations;
+  },
+
+  setTranslations(locale: Locale, version: string, translations: Translations): void {
+    store.set(TRANSLATIONS, { locale, translations, version } satisfies PersistedTranslations, true);
+  },
 };
+
+/**
+ * Introduced in 2.15.26 on 2026/04/27.
+ * Life expectancy: 1y.
+ */
+function migrateLegacySettings(): Partial<SettingsState> {
+  const settings: Partial<SettingsState> = {};
+  let hasLegacy = false;
+
+  for (const [setting, legacyKey] of Object.entries(LEGACY_KEYS) as [keyof SettingsState, string][]) {
+    if (store.has(legacyKey)) {
+      settings[setting] = store.get(legacyKey);
+      store.remove(legacyKey);
+      hasLegacy = true;
+    }
+  }
+
+  if (hasLegacy) {
+    store.set(SETTINGS, settings, true);
+  }
+
+  return settings;
+}
+
+/**
+ * The 'hidden' showCoordinates option was removed on 2026/08/13.
+ * Life expectancy: 1y.
+ */
+function migrateHiddenShowCoordinates(settings: Partial<SettingsState>): Partial<SettingsState> {
+  if (String(settings.showCoordinates) !== 'hidden') {
+    return settings;
+  }
+
+  const migrated: Partial<SettingsState> = { ...settings, showCoordinates: 'original' };
+  store.set(SETTINGS, migrated, true);
+  return migrated;
+}

package/src/state/rack/initialState.ts

@@ -1,6 +1,5 @@
 import { getConfig } from '@scrabble-solver/configs';
 
-import { localStorage } from '../localStorage';
 import { settingsInitialState } from '../settings';
 
 import type { RackState } from './types';
@@ -9,4 +8,4 @@ const defaultConfig = getConfig(settingsInitialState.game, settingsInitialState.
 
 export const rackDefaultState: RackState = Array(defaultConfig.rackSize).fill(null);
 
-export const rackInitialState: RackState = localStorage.getRack() ?? rackDefaultState;
+export const rackInitialState: RackState = rackDefaultState;

package/src/state/rack/slice.ts

@@ -1,7 +1,10 @@
 import { createSlice, type PayloadAction } from '@reduxjs/toolkit';
 import { type Tile } from '@scrabble-solver/types';
 
-import { arrayEquals, createNullMovingComparator, inverseDirection, zipCharactersAndTiles } from '@/lib';
+import { arrayEquals } from '@/lib/arrayEquals';
+import { createNullMovingComparator } from '@/lib/createNullMovingComparator';
+import { inverseDirection } from '@/lib/inverseDirection';
+import { zipCharactersAndTiles } from '@/lib/zipCharactersAndTiles';
 import { type AutoGroupTiles, type Rack } from '@/types';
 
 import { rackDefaultState, rackInitialState } from './initialState';

package/src/state/results/lib.ts

@@ -1,6 +1,10 @@
 import { type Result, type ShowCoordinates } from '@scrabble-solver/types';
 
-import { createKeyComparator, createRegExp, createStringComparator, getCoordinate, reverseComparator } from '@/lib';
+import { createKeyComparator } from '@/lib/createKeyComparator';
+import { createRegExp } from '@/lib/createRegExp';
+import { createStringComparator } from '@/lib/createStringComparator';
+import { getCoordinate } from '@/lib/getCoordinate';
+import { reverseComparator } from '@/lib/reverseComparator';
 import {
   type CellFilter,
   type Comparator,
@@ -11,10 +15,6 @@ import {
 } from '@/types';
 
 export const getCoordinates = (result: Result, showCoordinates: ShowCoordinates): string => {
-  if (showCoordinates === 'hidden') {
-    return '';
-  }
-
   const firstCell = result.cells[0];
   const x = getCoordinate(firstCell.x, showCoordinates === 'original' ? 'letter' : 'number');
   const y = getCoordinate(firstCell.y, showCoordinates === 'original' ? 'number' : 'letter');

package/src/state/results/selectors.ts

@@ -1,6 +1,6 @@
 import { createSelector } from '@reduxjs/toolkit';
 
-import { createRegExp } from '@/lib';
+import { createRegExp } from '@/lib/createRegExp';
 
 import { selectCellFilters } from '../cellFilters';
 import { selectLocale, selectShowCoordinates } from '../settings';