@scrabble-solver/scrabble-solver 2.8.6 → 2.8.8

package/src/lib/index.ts

@@ -15,8 +15,9 @@ export { default as getTotalRemainingTilesCount } from './getTotalRemainingTiles
 export { default as getTileSizes } from './getTileSizes';
 export { default as inverseDirection } from './inverseDirection';
 export { default as isCtrl } from './isCtrl';
-export { default as isLocale } from './isLocale';
 export { default as isMac } from './isMac';
+export { default as isRegExp } from './isRegExp';
+export { default as isStringArray } from './isStringArray';
 export { default as memoize } from './memoize';
 export { default as noop } from './noop';
 export { default as numberComparator } from './numberComparator';

package/src/lib/isRegExp.ts

@@ -0,0 +1,11 @@
+const isRegExp = (value: string): boolean => {
+  try {
+    // eslint-disable-next-line no-new
+    new RegExp(value);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export default isRegExp;

package/src/lib/isStringArray.ts

@@ -0,0 +1,5 @@
+const isStringArray = (value: unknown): value is string[] => {
+  return Array.isArray(value) && value.every((item) => typeof item === 'string');
+};
+
+export default isStringArray;

package/src/lib/sortResults.ts

@@ -6,13 +6,13 @@ import createKeyComparator from './createKeyComparator';
 import reverseComparator from './reverseComparator';
 
 const comparators: Record<ResultColumn, Comparator<Result>> = {
-  [ResultColumn.BlanksCount]: createKeyComparator('numberOfBlanks'),
-  [ResultColumn.ConsonantsCount]: createKeyComparator('numberOfConsonants'),
+  [ResultColumn.BlanksCount]: createKeyComparator('blanksCount'),
+  [ResultColumn.ConsonantsCount]: createKeyComparator('consonantsCount'),
   [ResultColumn.Points]: createKeyComparator('points'),
-  [ResultColumn.TilesCount]: createKeyComparator('numberOfTiles'),
-  [ResultColumn.VowelsCount]: createKeyComparator('numberOfVowels'),
+  [ResultColumn.TilesCount]: createKeyComparator('tilesCount'),
+  [ResultColumn.VowelsCount]: createKeyComparator('vowelsCount'),
   [ResultColumn.Word]: createKeyComparator('word'),
-  [ResultColumn.WordsCount]: createKeyComparator('numberOfWords'),
+  [ResultColumn.WordsCount]: createKeyComparator('wordsCount'),
 };
 
 const sortResults = (

package/src/pages/api/dictionary/[locale]/[word].ts

@@ -1,45 +1,69 @@
+import { scrabble } from '@scrabble-solver/configs';
 import logger from '@scrabble-solver/logger';
-import { Locale } from '@scrabble-solver/types';
+import { isLocale, Locale } from '@scrabble-solver/types';
 import { getWordDefinition } from '@scrabble-solver/word-definitions';
 import { NextApiRequest, NextApiResponse } from 'next';
 
-import { getServerLoggingData, validateLocale, validateWord } from 'api';
+import { getServerLoggingData } from 'api';
 
 interface RequestData {
   locale: Locale;
-  word: string;
+  words: string[];
 }
 
+const MAXIMUM_WORDS_COUNT = scrabble['en-US'].maximumCharactersCount;
+
 const dictionary = async (request: NextApiRequest, response: NextApiResponse): Promise<void> => {
   const meta = getServerLoggingData(request);
 
   try {
-    const { locale, word } = parseRequest(request);
+    const { locale, words } = parseRequest(request);
+
     logger.info('dictionary - request', {
       meta,
       payload: {
         locale,
-        word,
+        words,
       },
     });
-    const result = await getWordDefinition(locale, word);
-    response.status(200).send(result.toJson());
+
+    const results = await Promise.all(words.map((word) => getWordDefinition(locale, word)));
+    response.status(200).send(results.map((result) => result.toJson()));
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Unknown error';
     logger.error('dictionary - error', { error, meta });
     response.status(500).send({ error: 'Server error', message });
+    throw error;
   }
 };
 
 const parseRequest = (request: NextApiRequest): RequestData => {
   const { locale, word } = request.query;
 
-  validateLocale(locale);
-  validateWord(word);
+  if (!isLocale(locale)) {
+    throw new Error('Invalid "locale" parameter');
+  }
+
+  if (typeof word !== 'string' || word.length === 0) {
+    throw new Error('Invalid "word" parameter');
+  }
+
+  const words = Array.from(
+    new Set(
+      word
+        .split(',')
+        .map((part) => part.trim())
+        .filter(Boolean),
+    ),
+  );
+
+  if (words.length > MAXIMUM_WORDS_COUNT) {
+    throw new Error('Invalid "word" parameter');
+  }
 
   return {
-    locale: locale as Locale,
-    word: word as string,
+    locale,
+    words,
   };
 };
 

package/src/pages/api/solve.ts

@@ -1,12 +1,13 @@
-import { getLocaleConfig } from '@scrabble-solver/configs';
+import { getLocaleConfig, isConfigId } from '@scrabble-solver/configs';
 import { BLANK } from '@scrabble-solver/constants';
 import { dictionaries } from '@scrabble-solver/dictionaries';
 import logger from '@scrabble-solver/logger';
 import Solver from '@scrabble-solver/solver';
-import { Board, Config, Locale, Tile } from '@scrabble-solver/types';
+import { Board, Config, isBoardJson, isLocale, Locale, Tile } from '@scrabble-solver/types';
 import { NextApiRequest, NextApiResponse } from 'next';
 
-import { getServerLoggingData, validateBoard, validateCharacters, validateConfigId, validateLocale } from 'api';
+import { getServerLoggingData, isBoardValid } from 'api';
+import { isStringArray } from 'lib';
 
 interface RequestData {
   board: Board;
@@ -20,6 +21,7 @@ const solve = async (request: NextApiRequest, response: NextApiResponse): Promis
 
   try {
     const { board, characters, config, locale } = parseRequest(request);
+
     logger.info('solve - request', {
       meta,
       payload: {
@@ -31,7 +33,7 @@ const solve = async (request: NextApiRequest, response: NextApiResponse): Promis
         locale,
       },
     });
-    validateRequest({ board, characters, config, locale });
+
     const trie = await dictionaries.get(locale);
     const tiles = characters.map((character) => new Tile({ character, isBlank: character === BLANK }));
     const solver = new Solver(config, trie);
@@ -41,33 +43,51 @@ const solve = async (request: NextApiRequest, response: NextApiResponse): Promis
     const message = error instanceof Error ? error.message : 'Unknown error';
     logger.error('solve - error', { error, meta });
     response.status(500).send({ error: 'Server error', message });
+    throw error;
   }
 };
 
 const parseRequest = (request: NextApiRequest): RequestData => {
-  const { board, characters, configId, locale } = request.body;
+  const { board: boardJson, characters, configId, locale } = request.body;
+
+  if (!isLocale(locale)) {
+    throw new Error('Invalid "locale" parameter');
+  }
+
+  if (!isConfigId(configId)) {
+    throw new Error('Invalid "configId" parameter');
+  }
 
-  validateConfigId(configId);
-  validateLocale(locale);
   const config = getLocaleConfig(configId, locale);
-  validateBoard(board, config);
-  validateCharacters(characters, config);
 
-  return {
-    board: Board.fromJson(board),
-    characters,
-    config,
-    locale,
-  };
-};
+  if (!isBoardJson(boardJson) || !isBoardValid(boardJson, config)) {
+    throw new Error('Invalid "board" parameter');
+  }
+
+  if (!isStringArray(characters) || characters.length === 0) {
+    throw new Error('Invalid "characters" parameter');
+  }
 
-const validateRequest = ({ board, characters, config }: RequestData): void => {
+  for (const character of characters) {
+    if (!config.hasCharacter(character) && character !== BLANK) {
+      throw new Error('Invalid "characters" parameter');
+    }
+  }
+
+  const board = Board.fromJson(boardJson);
   const blankTilesCount = characters.filter((character) => character === BLANK).length;
   const blanksCount = board.getBlanksCount() + blankTilesCount;
 
-  if (blanksCount > config.numberOfBlanks) {
-    throw new Error(`Too many blank tiles passed (board: ${board.getBlanksCount()}, tiles: ${blankTilesCount})`);
+  if (blanksCount > config.blanksCount) {
+    throw new Error('Too many blank tiles passed');
   }
+
+  return {
+    board,
+    characters,
+    config,
+    locale,
+  };
 };
 
 export default solve;

package/src/pages/api/visit.ts

@@ -13,6 +13,7 @@ const visit = async (request: NextApiRequest, response: NextApiResponse): Promis
     const message = error instanceof Error ? error.message : 'Unknown error';
     logger.error('visit - error', { error, meta });
     response.status(500).send({ error: 'Server error', message });
+    throw error;
   }
 };
 

package/src/pages/index.module.scss

@@ -25,11 +25,15 @@
   padding: var(--spacing--l);
 }
 
-.logoContainer {
+.navLogo {
   display: flex;
   flex: 1;
 }
 
+.logoContainer {
+  display: flex;
+}
+
 .logo {
   height: 60px;
   user-select: none;
@@ -127,13 +131,3 @@
 .submitInput {
   display: none;
 }
-
-.version {
-  position: fixed;
-  bottom: var(--spacing--m);
-  left: 0;
-  right: 0;
-  font-size: var(--font--size--xs);
-  color: var(--color--background);
-  text-align: center;
-}

package/src/pages/index.tsx

@@ -74,8 +74,10 @@ const Index: FunctionComponent<Props> = ({ version }) => {
     <>
       <div className={classNames(styles.index, { [styles.initialized]: isInitialized })}>
         <div className={styles.nav}>
-          <div className={styles.logoContainer}>
-            <Logo className={styles.logo} />
+          <div className={styles.navLogo}>
+            <a className={styles.logoContainer} href="/" title={version}>
+              <Logo className={styles.logo} />
+            </a>
           </div>
 
           <NavButtons
@@ -114,8 +116,6 @@ const Index: FunctionComponent<Props> = ({ version }) => {
           <Rack className={styles.rack} />
           <input className={styles.submitInput} tabIndex={-1} type="submit" />
         </form>
-
-        <span className={styles.version}>v{version}</span>
       </div>
 
       <Settings isOpen={showSettings} onClose={() => setShowSettings(false)} />
@@ -138,7 +138,7 @@ const readVersion = async (): Promise<string> => {
   const packageJsonFilepath = path.resolve(process.cwd(), 'package.json');
   const data = await fs.promises.readFile(packageJsonFilepath, 'utf-8');
   const packageJson = JSON.parse(data);
-  return packageJson.version;
+  return `v${packageJson.version}`;
 };
 
 export default Index;

package/src/sdk/{findWordDefinition.ts → findWordDefinitions.ts}

@@ -1,9 +1,9 @@
 import { Locale, WordDefinition } from '@scrabble-solver/types';
 
-const findWordDefinition = async (locale: Locale, word: string): Promise<WordDefinition> => {
+const findWordDefinitions = async (locale: Locale, word: string): Promise<WordDefinition[]> => {
   const url = `/api/dictionary/${locale}/${word}`;
   const json = await fetch(url).then((response) => response.json());
-  return WordDefinition.fromJson(json);
+  return json.map(WordDefinition.fromJson);
 };
 
-export default findWordDefinition;
+export default findWordDefinitions;

package/src/sdk/index.ts

@@ -1,3 +1,3 @@
-export { default as findWordDefinition } from './findWordDefinition';
+export { default as findWordDefinitions } from './findWordDefinitions';
 export { default as solve } from './solve';
 export { default as visit } from './visit';

package/src/state/rootReducer.ts

@@ -1,9 +1,18 @@
 import { combineReducers } from 'redux';
 
-import { boardSlice, dictionarySlice, rackSlice, resultsSlice, settingsSlice, solveSlice } from './slices';
+import {
+  boardSlice,
+  dictionarySlice,
+  cellFilterSlice,
+  rackSlice,
+  resultsSlice,
+  settingsSlice,
+  solveSlice,
+} from './slices';
 
 const rootReducer = combineReducers({
   board: boardSlice.reducer,
+  cellFilter: cellFilterSlice.reducer,
   dictionary: dictionarySlice.reducer,
   rack: rackSlice.reducer,
   results: resultsSlice.reducer,

package/src/state/sagas.ts

@@ -3,22 +3,31 @@ import { Result } from '@scrabble-solver/types';
 import { call, delay, put, select, takeEvery, takeLatest } from 'redux-saga/effects';
 
 import { memoize } from 'lib';
-import { findWordDefinition, solve, visit } from 'sdk';
+import { findWordDefinitions, solve, visit } from 'sdk';
 
 import { initialize, reset } from './actions';
 import {
   selectAutoGroupTiles,
   selectBoard,
+  selectCellIsFiltered,
   selectCharacters,
   selectConfig,
   selectDictionary,
   selectLocale,
 } from './selectors';
-import { boardSlice, dictionarySlice, rackSlice, resultsSlice, settingsSlice, solveSlice } from './slices';
+import {
+  boardSlice,
+  cellFilterSlice,
+  dictionarySlice,
+  rackSlice,
+  resultsSlice,
+  settingsSlice,
+  solveSlice,
+} from './slices';
 
 const SUBMIT_DELAY = 150;
 
-const memoizedFindWordDefinition = memoize(findWordDefinition);
+const memoizedFindWordDefinitions = memoize(findWordDefinitions);
 
 // Can't conveniently type generators for sagas yet,
 // see: https://github.com/microsoft/TypeScript/issues/43632
@@ -26,6 +35,7 @@ const memoizedFindWordDefinition = memoize(findWordDefinition);
 type AnyGenerator = Generator<any, any, any>;
 
 export function* rootSaga(): AnyGenerator {
+  yield takeEvery(boardSlice.actions.changeCellValue.type, onCellValueChange);
   yield takeEvery(resultsSlice.actions.applyResult.type, onApplyResult);
   yield takeEvery(resultsSlice.actions.changeResultCandidate.type, onResultCandidateChange);
   yield takeEvery(settingsSlice.actions.changeConfigId.type, onConfigIdChange);
@@ -36,9 +46,18 @@ export function* rootSaga(): AnyGenerator {
   yield takeLatest(solveSlice.actions.submit.type, onSubmit);
 }
 
+function* onCellValueChange({ payload }: PayloadAction<{ value: string; x: number; y: number }>): AnyGenerator {
+  const isFiltered = yield select((state) => selectCellIsFiltered(state, payload));
+
+  if (isFiltered) {
+    yield put(cellFilterSlice.actions.toggle(payload));
+  }
+}
+
 function* onApplyResult({ payload: result }: PayloadAction<Result>): AnyGenerator {
   const autoGroupTiles = yield select(selectAutoGroupTiles);
   yield put(boardSlice.actions.applyResult(result));
+  yield put(cellFilterSlice.actions.reset());
   yield put(rackSlice.actions.removeTiles(result.tiles));
   yield put(rackSlice.actions.groupTiles(autoGroupTiles));
 }
@@ -53,13 +72,13 @@ function* onDictionarySubmit(): AnyGenerator {
   const { input: word } = yield select(selectDictionary);
   const locale = yield select(selectLocale);
 
-  if (!memoizedFindWordDefinition.hasCache(locale, word)) {
+  if (!memoizedFindWordDefinitions.hasCache(locale, word)) {
     yield delay(SUBMIT_DELAY);
   }
 
   try {
-    const wordDefinition = yield call(memoizedFindWordDefinition, locale, word);
-    yield put(dictionarySlice.actions.submitSuccess(wordDefinition));
+    const wordDefinitions = yield call(memoizedFindWordDefinitions, locale, word);
+    yield put(dictionarySlice.actions.submitSuccess(wordDefinitions));
   } catch (error) {
     yield put(dictionarySlice.actions.submitFailure());
   }
@@ -72,6 +91,7 @@ function* onInitialize(): AnyGenerator {
 
 function* onReset(): AnyGenerator {
   yield put(boardSlice.actions.reset());
+  yield put(cellFilterSlice.actions.reset());
   yield put(dictionarySlice.actions.reset());
   yield put(rackSlice.actions.reset());
   yield put(resultsSlice.actions.reset());
@@ -85,7 +105,7 @@ function* onLocaleChange(): AnyGenerator {
 
 function* onResultCandidateChange({ payload: result }: PayloadAction<Result | null>): AnyGenerator {
   if (result) {
-    yield put(dictionarySlice.actions.changeInput(result.word));
+    yield put(dictionarySlice.actions.changeInput(result.words.join(', ')));
     yield put(dictionarySlice.actions.submit());
   }
 }
@@ -121,12 +141,12 @@ function* ensureProperTilesCount(): AnyGenerator {
   const { config } = yield select(selectConfig);
   const characters = yield select(selectCharacters);
 
-  if (config.maximumNumberOfCharacters > characters.length) {
-    const differenceCount = Math.abs(config.maximumNumberOfCharacters - characters.length);
+  if (config.maximumCharactersCount > characters.length) {
+    const differenceCount = Math.abs(config.maximumCharactersCount - characters.length);
     yield put(rackSlice.actions.init([...characters, ...Array(differenceCount).fill(null)]));
-  } else if (config.maximumNumberOfCharacters < characters.length) {
-    const nonNulls = characters.filter(Boolean).slice(0, config.maximumNumberOfCharacters);
-    const differenceCount = Math.abs(config.maximumNumberOfCharacters - nonNulls.length);
+  } else if (config.maximumCharactersCount < characters.length) {
+    const nonNulls = characters.filter(Boolean).slice(0, config.maximumCharactersCount);
+    const differenceCount = Math.abs(config.maximumCharactersCount - nonNulls.length);
     const autoGroupTiles = yield select(selectAutoGroupTiles);
     yield put(rackSlice.actions.init([...nonNulls, ...Array(differenceCount).fill(null)]));
     yield put(rackSlice.actions.groupTiles(autoGroupTiles));

package/src/state/selectors.ts

@@ -1,6 +1,6 @@
 import { createSelector } from '@reduxjs/toolkit';
 import { getLocaleConfig } from '@scrabble-solver/configs';
-import { Cell, Config, Tile } from '@scrabble-solver/types';
+import { Cell, Config, Result, Tile } from '@scrabble-solver/types';
 
 import i18n from 'i18n';
 import { findCell, getRemainingTiles, getRemainingTilesGroups, sortResults, unorderedArraysEqual } from 'lib';
@@ -10,6 +10,8 @@ import { RootState } from './types';
 
 const selectCell = (_: unknown, cell: Cell): Cell => cell;
 
+const selectPoint = (_: unknown, point: { x: number; y: number }): { x: number; y: number } => point;
+
 const selectCharacter = (_: unknown, character: string | null): string | null => character;
 
 const selectTile = (_: unknown, tile: Tile | null): Tile | null => tile;
@@ -18,6 +20,8 @@ const selectBoardRoot = (state: RootState): RootState['board'] => state.board;
 
 const selectDictionaryRoot = (state: RootState): RootState['dictionary'] => state.dictionary;
 
+const selectCellFilterRoot = (state: RootState): RootState['cellFilter'] => state.cellFilter;
+
 const selectRackRoot = (state: RootState): RootState['rack'] => state.rack;
 
 const selectResultsRoot = (state: RootState): RootState['results'] => state.results;
@@ -38,6 +42,12 @@ export const selectConfigId = createSelector([selectSettingsRoot], (settings) =>
 
 export const selectConfig = createSelector([selectConfigId, selectLocale], getLocaleConfig);
 
+export const selectCellFilter = selectCellFilterRoot;
+
+export const selectCellIsFiltered = createSelector([selectCellFilter, selectPoint], (cellFilter, { x, y }) => {
+  return cellFilter.some((cell) => cell.x === x && cell.y === y);
+});
+
 export const selectResults = createSelector([selectResultsRoot], (results) => results.results);
 
 export const selectResultsQuery = createSelector([selectResultsRoot], (results) => results.query);
@@ -51,16 +61,40 @@ export const selectSortedResults = createSelector(
   sortResults,
 );
 
+const filterResultsByQuery = (results: Result[], query: string): Result[] => {
+  if (query.trim().length === 0) {
+    return results;
+  }
+
+  let regExp: RegExp | undefined;
+
+  try {
+    regExp = new RegExp(query, 'gi');
+  } catch {
+    return results;
+  }
+
+  return results.filter((result) => {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return regExp!.test(result.word);
+  });
+};
+
 export const selectSortedFilteredResults = createSelector(
-  [selectSortedResults, selectResultsQuery],
-  (results, query) => {
-    if (!results || query.trim().length === 0) {
+  [selectSortedResults, selectResultsQuery, selectCellFilter],
+  (results, query, cellFilter) => {
+    if (!results) {
       return results;
     }
 
-    return results.filter((result) => {
-      const regExp = new RegExp(query, 'gi');
-      return regExp.test(result.word);
+    const filteredByQuery = filterResultsByQuery(results, query);
+
+    if (!cellFilter) {
+      return filteredByQuery;
+    }
+
+    return filteredByQuery.filter((result) => {
+      return cellFilter.every(({ x, y }) => result.cells.some((cell) => cell.x === x && cell.y === y));
     });
   },
 );

package/src/state/slices/cellFilterInitialState.ts

@@ -0,0 +1,7 @@
+import { Cell } from '@scrabble-solver/types';
+
+export type Point = Pick<Cell, 'x' | 'y'>;
+
+const cellFilterInitialState: Point[] = [];
+
+export default cellFilterInitialState;

package/src/state/slices/cellFilterSlice.ts

@@ -0,0 +1,24 @@
+import { createSlice, PayloadAction } from '@reduxjs/toolkit';
+
+import cellFilterInitialState, { Point } from './cellFilterInitialState';
+
+const cellFilterSlice = createSlice({
+  initialState: cellFilterInitialState,
+  name: 'cellFilter',
+  reducers: {
+    toggle: (state, action: PayloadAction<Point>) => {
+      const { x, y } = action.payload;
+      const has = state.some((point) => point.x === x && point.y === y);
+
+      if (has) {
+        return state.filter((point) => point.x !== x || point.y !== y);
+      }
+
+      return [...state, action.payload];
+    },
+
+    reset: () => cellFilterInitialState,
+  },
+});
+
+export default cellFilterSlice;

package/src/state/slices/dictionaryInitialState.ts

@@ -1,9 +1,9 @@
+import { WordDefinition } from '@scrabble-solver/types';
+
 const dictionaryInitialState = {
-  definitions: [] as string[],
   input: '',
-  isAllowed: null as boolean | null,
   isLoading: false,
-  word: undefined as string | undefined,
+  results: [] as WordDefinition[],
 };
 
 export default dictionaryInitialState;

package/src/state/slices/dictionarySlice.ts

@@ -16,30 +16,24 @@ const dictionarySlice = createSlice({
     submit: (state) => {
       return {
         ...state,
-        definitions: dictionaryInitialState.definitions,
-        isAllowed: dictionaryInitialState.isAllowed,
         isLoading: true,
-        word: dictionaryInitialState.word,
+        results: dictionaryInitialState.results,
       };
     },
 
     submitFailure: (state) => {
       return {
         ...state,
-        definitions: dictionaryInitialState.definitions,
-        isAllowed: false,
         isLoading: false,
-        word: state.input,
+        results: dictionaryInitialState.results,
       };
     },
 
-    submitSuccess: (state, action: PayloadAction<WordDefinition>) => {
+    submitSuccess: (state, action: PayloadAction<WordDefinition[]>) => {
       return {
         ...state,
-        definitions: action.payload.definitions,
-        isAllowed: action.payload.isAllowed,
         isLoading: false,
-        word: action.payload.word,
+        results: action.payload,
       };
     },
   },

package/src/state/slices/index.ts

@@ -1,5 +1,7 @@
 export { default as boardInitialState } from './boardInitialState';
 export { default as boardSlice } from './boardSlice';
+export { default as cellFilterInitialState } from './cellFilterInitialState';
+export { default as cellFilterSlice } from './cellFilterSlice';
 export { default as dictionaryInitialState } from './dictionaryInitialState';
 export { default as dictionarySlice } from './dictionarySlice';
 export { default as rackInitialState } from './rackInitialState';

package/src/types/index.ts

@@ -30,6 +30,7 @@ export enum ResultColumn {
 }
 
 export type TranslationKey =
+  | 'cell.filter-cell'
   | 'cell.set-blank'
   | 'cell.set-not-blank'
   | 'cell.toggle-direction'

package/.next/static/VjSpyGDWyVaO0muz54q_j/_buildManifest.js

@@ -1 +0,0 @@
-self.__BUILD_MANIFEST=function(s,a,e){return{__rewrites:{beforeFiles:[],afterFiles:[],fallback:[]},"/":[s,a,e,"static/css/3159cfe62ff742a3.css","static/chunks/pages/index-13ea7770a65c69ee.js"],"/404":[s,a,e,"static/chunks/pages/404-30c06e61d256c5b2.js"],"/_error":["static/chunks/pages/_error-a4ba2246ff8fb532.js"],sortedPages:["/","/404","/_app","/_error"]}}("static/chunks/758-f333b1dcdb941547.js","static/css/729bb37fe8f9bee6.css","static/chunks/56-e2797384ae4b0fc0.js"),self.__BUILD_MANIFEST_CB&&self.__BUILD_MANIFEST_CB();