{"version":3,"sources":["components/layout/Header.tsx","context/SudokuContext.tsx","components/layout/GameSection.tsx","components/Difficulty.tsx","components/Timer.tsx","components/Numbers.tsx","components/Action.tsx","components/Mode.tsx","components/layout/StatusSection.tsx","components/layout/Footer.tsx","solver/sudoku.js","solver/UniqueSudoku.tsx","Game.tsx","App.tsx","index.tsx"],"names":["Header","props","className","onClick","SudokuContext","createContext","numberSelected","setNumberSelected","gameArray","setGameArray","difficulty","setDifficulty","timeGameStarted","moment","setTimeGameStarted","fastMode","setFastMode","cellSelected","setCellSelected","initArray","setInitArray","won","setWon","SudokuProvider","children","useState","Provider","value","useSudokuContext","useContext","GameSection","rows","_isCellSameAsSelectedCell","row","column","_selectedCell","indexOfArray","highlight","_unselectedCell","map","Difficulty","name","defaultValue","onChange","Timer","currentTime","setCurrentTime","useEffect","setTimeout","secondsTotal","diff","duration","hours","minutes","seconds","stringTimer","getTimer","Numbers","onClickNumber","number","toString","Svg","action","height","viewBox","width","xmlns","d","fill","version","id","x","y","Action","onClickAction","Mode","mode","type","onClickMode","StatusSection","onClickUndo","onClickErase","onClickHint","onClickMistakesMode","onClickFastMode","Footer","href","sudoku","ROWS","COLS","DIGITS","SQUARES","UNITS","SQUARE_UNITS_MAP","SQUARE_PEERS_MAP","DIFFICULTY","BLANK_CHAR","BLANK_BOARD","generate","unique","easy","_force_range","NR_SQUARES","blank_board","i","candidates","_get_candidates_map","shuffled_squares","_shuffle","si","square","rand_candidate_idx","_rand_range","length","rand_candidate","_assign","single_candidates","push","_strip_dups","board","givens_idxs","nr_givens","target","parseInt","substr","solve","reverse","report","validate_board","_in","result","_search","solution","get_candidates","candidates_map","cur_row","candidate_map","squares_values_map","_get_square_vals_map","val","max_nr_candidates","nr_candidates","min_nr_candidates","min_candidates_square","min_candidates","vi","candidates_copy","JSON","parse","stringify","candidates_next","other_vals","replace","ovi","other_val","_eliminate","target_val","pi","peer","candidates_new","ui","unit","val_places","unit_square","squares_vals_map","_get_square_units_map","squares","units","square_unit_map","cur_square","cur_square_units","cur_unit","indexOf","_get_square_peers_map","units_map","square_peers_map","cur_square_peers","sui","cur_unit_square","_get_all_units","cols","ri","_cross","ci","row_squares","col_squares","rsi","csi","board_string_to_grid","board_string","board_grid_to_string","board_grid","r","c","print_board","display_string","console","log","a","b","ai","bi","v","seq","_first_true","shuffled","ti","max","min","Math","floor","random","seq_set","dup_map","e","nr","nullArray","_getIndexOfCell","box","cell","_getBoxCenter","_cellAvailable","tempInitArray","getUniqueSudoku","temporaryInitArray","slice","temporarySolvedArray","str","forEach","index","solvedArray","minimumCells","maximumCells","totalCells","currentDifficulty","boxCounts","boxesAvailable","cellsAvailable","j","_generateUniqueSudoku","Game","mistakesMode","setMistakesMode","history","setHistory","setSolvedArray","overlay","setOverlay","_createNewGame","_fillCell","tempArray","tempHistory","every","cellIndex","_isSolved","_userFillCell","onClickCell","onChangeDifficulty","pop","undefined","App","render","document","getElementById"],"mappings":"6KASaA,EAAS,SAACC,GACrB,OACE,yBAAQC,UAAU,SAAlB,UACE,oCACI,sBAAMA,UAAU,oBAAhB,gBAA6C,sBAAMA,UAAU,oBAAhB,mBAEjD,oBAAIC,QAASF,EAAME,QAAnB,0BCQAC,EAAgBC,wBAAkC,CAAEC,eAAgB,IAAKC,kBAAmB,aACxCC,UAAW,GAAIC,aAAc,aAC7BC,WAAY,OAAQC,cAAe,aACnCC,gBAAiBC,MAAUC,mBAAoB,aAC/CC,UAAU,EAAOC,YAAa,aAC9BC,cAAe,EAAGC,gBAAiB,aACnCC,UAAW,GAAIC,aAAc,aAC7BC,KAAK,EAAOC,OAAQ,eAMjEC,EAAiB,SAAC,GAAuC,IAArCC,EAAoC,EAApCA,SAAoC,EACvBC,mBAAiB,KADM,mBAC7DnB,EAD6D,KAC7CC,EAD6C,OAEjCkB,mBAAmB,IAFc,mBAE7DjB,EAF6D,KAElDC,EAFkD,OAGhCgB,mBAAiB,QAHe,mBAG7Df,EAH6D,KAGlDC,EAHkD,OAIrBc,mBAAwBZ,OAJH,mBAI7DD,EAJ6D,KAI5CE,EAJ4C,OAKnCW,oBAAkB,GALiB,mBAK7DV,EAL6D,KAKnDC,EALmD,OAM3BS,oBAAkB,GANS,mBAM7DR,EAN6D,KAM/CC,EAN+C,OAOjCO,mBAAmB,IAPc,mBAO7DN,EAP6D,KAOlDC,EAPkD,OAQ7CK,oBAAkB,GAR2B,mBAQ7DJ,EAR6D,KAQxDC,EARwD,KAUnE,OACE,cAAClB,EAAcsB,SAAf,CAAwBC,MACtB,CACErB,iBAAgBC,oBAChBC,YAAWC,eACXC,aAAWC,gBACXC,kBAAiBE,qBACjBC,WAAUC,cACVC,eAAcC,kBACdC,YAAWC,eACXC,MAAKC,UATT,SAYGE,KAKMI,EAAmB,kBAA0BC,qBAAWzB,ICtDxD0B,EAAc,SAAC7B,GAC1B,IAAM8B,EAAO,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GADwB,EAMlCH,IAJdtB,EAFgD,EAEhDA,eACAE,EAHgD,EAGhDA,UACAO,EAJgD,EAIhDA,SACAE,EALgD,EAKhDA,aACAE,EANgD,EAMhDA,UAwCN,SAASa,EAA0BC,EAAaC,GAC9C,OAAInB,EACET,IAAmBE,EAAgB,EAANyB,EAAUC,GAKvCjB,IAAuB,EAANgB,EAAUC,GAGC,MAA5B1B,EAAUS,KAGVT,EAAUS,KAAkBT,EAAgB,EAANyB,EAAUC,SAApD,GASJ,SAASC,EAAcC,EAAsBT,EAAeU,GAC1D,MAAc,MAAVV,EAC8B,MAA5BR,EAAUiB,GAEV,oBAAIlC,UAAS,wDAAmDmC,EAAnD,YAA2FlC,QAAS,kBAAMF,EAAME,QAAQiC,IAArI,SAAqJT,GAA3DS,GAI1F,oBAAIlC,UAAS,oDAA+CmC,EAA/C,YAAuFlC,QAAS,kBAAMF,EAAME,QAAQiC,IAAjI,SAAiJT,GAA3DS,GAKxF,oBAAIlC,UAAS,iCAA4BmC,EAA5B,YAAoElC,QAAS,kBAAMF,EAAME,QAAQiC,IAA9G,SAA8HT,GAA3DS,GAQzE,SAASE,EAAgBF,EAAsBT,GAC7C,MAAc,MAAVA,EAC8B,MAA5BR,EAAUiB,GAEV,oBAAIlC,UAAU,oCAAuDC,QAAS,kBAAMF,EAAME,QAAQiC,IAAlG,SAAkHT,GAA3DS,GAIvD,oBAAIlC,UAAU,gCAAmDC,QAAS,kBAAMF,EAAME,QAAQiC,IAA9F,SAA8GT,GAA3DS,GAKrD,oBAAIlC,UAAU,aAAgCC,QAAS,kBAAMF,EAAME,QAAQiC,IAA3E,SAA2FT,GAA3DS,GAKtC,OACE,yBAASlC,UAAU,OAAnB,SACE,uBAAOA,UAAU,cAAjB,SACE,gCAEI6B,EAAKQ,KAAI,SAACN,GACR,OACE,oBAAI/B,UAAU,YAAd,SAEI6B,EAAKQ,KAAI,SAACL,GACR,IAAME,EAAqB,EAANH,EAAUC,EACzBP,EAAQnB,EAAU4B,GAExB,OAAInB,IAAiBmB,EACZD,EAAcC,EAAcT,EAAO,aAGxCZ,EACqB,MAAnBT,GAA0B0B,EAA0BC,EAAKC,GACpDC,EAAcC,EAAcT,EAAO,IAEnCW,EAAgBF,EAAcT,IAGjB,IAAlBV,GAAuBe,EAA0BC,EAAKC,GACjDC,EAAcC,EAAcT,EAAO,IAEnCW,EAAgBF,EAAcT,OApBhBM,aClHlCO,EAAa,SAACvC,GAA4B,IAC/CS,EAAekB,IAAflB,WAEN,OACE,sBAAKR,UAAU,qBAAf,UACE,sBAAMA,UAAU,0BAAhB,iCACA,yBAAQuC,KAAK,4BAA4BvC,UAAU,4BAA4BwC,aAAchC,EAAYiC,SAAU1C,EAAM0C,SAAzH,UACE,wBAAQhB,MAAM,OAAd,kBACA,wBAAQA,MAAM,SAAd,oBACA,wBAAQA,MAAM,OAAd,yBCXKiB,EAAQ,WAAO,IAAD,EACWnB,mBAASZ,OADpB,mBACpBgC,EADoB,KACPC,EADO,OAEMlB,IAAzBhB,EAFmB,EAEnBA,gBAAiBS,EAFE,EAEFA,IA4BvB,OA1BA0B,qBAAU,WACH1B,GACH2B,YAAW,WAIbF,EAAejC,SAJY,QAyB3B,qBAAKX,UAAU,eAAf,SAlBF,WACE,IAAI+C,EAAeJ,EAAYK,KAAKtC,EAAiB,WACrD,GAAIqC,GAAgB,EAClB,MAAO,QACT,IAAIE,EAAWtC,IAAOsC,SAASF,EAAc,WACzCG,EAAQD,EAASC,QACjBC,EAAUF,EAASE,UACnBC,EAAUH,EAASG,UACnBC,EAAc,GAMlB,OAJAA,GAAeH,EAAaA,EAAQ,IAAM,GAC1CG,GAAeF,GAAWA,EAAU,GAAK,IAAM,IAAMA,EAAU,IAAM,MACrEE,GAAeD,EAAU,GAAK,IAAMA,EAAUA,EAMfE,MC7BtBC,EAAU,SAAC,GAAsC,IAApCC,EAAmC,EAAnCA,cAClBpD,EAAmBsB,IAAnBtB,eAEN,OACE,qBAAKJ,UAAU,kBAAf,SAEI,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAGqC,KAAI,SAACoB,GACvB,OAAIrD,IAAmBqD,EAAOC,WAE1B,qBAAK1D,UAAU,0CAAuDC,QAAS,kBAAMuD,EAAcC,EAAOC,aAA1G,SAAwHD,GAA1DA,GAI9D,qBAAKzD,UAAU,iBAA8BC,QAAS,kBAAMuD,EAAcC,EAAOC,aAAjF,SAA+FD,GAA1DA,SCT7CE,EAAM,SAAC5D,GACX,MAAqB,SAAjBA,EAAM6D,OAEN,sBAAK5D,UAAU,qBAAqB6D,OAAO,QAAQC,QAAQ,cAAcC,MAAM,QAAQC,MAAM,6BAA7F,UAA0H,sBAAMC,EAAE,yMAAyMC,KAAK,uBAAsB,sBAAMD,EAAE,ikBAAikBC,KAAK,0BAE55B,UAAjBnE,EAAM6D,OAEb,qBAAK5D,UAAU,qBAAqBmE,QAAQ,MAAMC,GAAG,UAAUJ,MAAM,6BAA6BK,EAAE,MAAMC,EAAE,MAAMR,QAAQ,sBAA1H,SAAgJ,sBAAMG,EAAE,sZAAsZC,KAAK,yBAE3hB,SAAjBnE,EAAM6D,OAEb,sBAAK5D,UAAU,qBAAqBmE,QAAQ,MAAMC,GAAG,SAASJ,MAAM,6BAA6BK,EAAE,MAAMC,EAAE,MAAMR,QAAQ,kBAAzH,UACE,sBAAMG,EAAE,ggBAAggBC,KAAK,uBAC7gB,sBAAMD,EAAE,gLAAgLC,KAAK,uBAC7L,sBAAMD,EAAE,0PAA0PC,KAAK,uBACvQ,sBAAMD,EAAE,8PAA8PC,KAAK,uBAC3Q,sBAAMD,EAAE,4HAA4HC,KAAK,uBACzI,sBAAMD,EAAE,6KAA6KC,KAAK,uBAC1L,sBAAMD,EAAE,qJAAqJC,KAAK,uBAClK,sBAAMD,EAAE,6JAA6JC,KAAK,uBAC1K,sBAAMD,EAAE,qKAAqKC,KAAK,0BAI/K,MAOEK,EAAS,SAACxE,GACrB,OACE,sBAAKC,UAA8B,SAAjBD,EAAM6D,OACJ,sBACiB,UAAjB7D,EAAM6D,OACN,uBACiB,SAAjB7D,EAAM6D,OACN,sBACA,GACF3D,QAASF,EAAMyE,cAPjC,UAQE,cAAC,EAAD,CAAKZ,OAAQ7D,EAAM6D,SACnB,mBAAG5D,UAAU,sBAAb,SAEqB,SAAjBD,EAAM6D,OACF,OACiB,UAAjB7D,EAAM6D,OACN,QACiB,SAAjB7D,EAAM6D,OACN,OACA,SCrDDa,EAAO,SAAC1E,GACnB,OACE,sBAAKC,UAA2B,aAAfD,EAAM2E,KACH,+BACA,2BAFpB,UAGE,wBAAO1E,UAA2B,aAAfD,EAAM2E,KACH,sCACA,kCAFtB,UAGE,uBAAOC,KAAK,aACZ,sBAAM3E,UAA2B,aAAfD,EAAM2E,KACF,sCACA,kCAChBzE,QAASF,EAAM6E,iBAGvB,mBAAG5E,UAAU,sBAAb,SAAoD,aAAfD,EAAM2E,KAC7B,gBACA,kBCRPG,EAAgB,SAAC9E,GAC5B,OACE,0BAASC,UAAU,SAAnB,UACE,cAAC,EAAD,CAAYyC,SAAU1C,EAAM0C,WAC5B,cAAC,EAAD,IACA,cAAC,EAAD,CAASe,cAAe,SAACC,GAAD,OAAY1D,EAAMyD,cAAcC,MACxD,sBAAKzD,UAAU,kBAAf,UACE,cAAC,EAAD,CAAQ4D,OAAO,OAAOY,cAAezE,EAAM+E,cAC3C,cAAC,EAAD,CAAQlB,OAAO,QAAQY,cAAezE,EAAMgF,eAC5C,cAAC,EAAD,CAAQnB,OAAO,OAAOY,cAAezE,EAAMiF,cAC3C,cAAC,EAAD,CAAMN,KAAK,WAAWE,YAAa7E,EAAMkF,sBACzC,cAAC,EAAD,CAAMP,KAAK,OAAOE,YAAa7E,EAAMmF,yBC1BhCC,EAAS,WACpB,OACE,wBAAQnF,UAAU,SAAlB,SACE,yEAA6C,mBAAGoF,KAAK,mCAAR,0B,OCG3CC,EAAS,CACbA,OAAgB,aACZC,EAAO,YACPC,EAAOF,EAAOG,OACdC,EAAU,KAEVC,EAAQ,KACRC,EAAmB,KACnBC,EAAmB,KAOnBC,EAAa,CACb,KAAgB,GAChB,OAAgB,GAChB,KAAgB,GAChB,YAAgB,GAChB,OAAgB,GAChB,QAAgB,IAIpBR,EAAOS,WAAa,IACpBT,EAAOU,YAAc,oFAiBrBV,EAAOW,SAAW,SAASxF,EAAYyF,GAqCV,kBAAfzF,GAAiD,qBAAfA,IACxCA,EAAaqF,EAAWrF,IAAeqF,EAAWK,MAItD1F,EAAa6E,EAAOc,aAAa3F,EAAY4F,GA3EhC,IA+EbH,EAASA,IAAU,EAInB,IADA,IAAII,EAAc,GACVC,EAAI,EAAGA,EAlFF,KAkFoBA,EAC7BD,GAAe,IAEnB,IAAIE,EAAalB,EAAOmB,oBAAoBH,GAGxCI,EAAmBpB,EAAOqB,SAASjB,GACvC,IAAI,IAAIkB,KAAMF,EAAiB,CAC3B,IAAIG,EAASH,EAAiBE,GAI1BE,EACIxB,EAAOyB,YAAYP,EAAWK,GAAQG,QAC1CC,EAAiBT,EAAWK,GAAQC,GACxC,IAAIxB,EAAO4B,QAAQV,EAAYK,EAAQI,GACnC,MAIJ,IAAIE,EAAoB,GACxB,IAAIP,KAAMlB,EAG2B,IAA9Bc,EAFHK,EAASnB,EAAQkB,IAEKI,QAClBG,EAAkBC,KAAKZ,EAAWK,IAM1C,GAAGM,EAAkBH,QAAUvG,GACvB6E,EAAO+B,YAAYF,GAAmBH,QAAU,EAAE,CACtD,IAAIM,EAAQ,GACRC,EAAc,GAClB,IAAIhB,KAAKb,EAE4B,IAA9Bc,EADHK,EAASnB,EAAQa,IACKS,QAClBM,GAASd,EAAWK,GACpBU,EAAYH,KAAKb,IAEjBe,GAAShC,EAAOS,WAMxB,IAAIyB,EAAYD,EAAYP,OAC5B,GAAGQ,EAAY/G,EAEX,IADA8G,EAAcjC,EAAOqB,SAASY,GAC1BhB,EAAI,EAAGA,EAAIiB,EAAY/G,IAAc8F,EAAE,CACvC,IAAIkB,EAASC,SAASH,EAAYhB,IAClCe,EAAQA,EAAMK,OAAO,EAAGF,GAAUnC,EAAOS,WACrCuB,EAAMK,OAAOF,EAAS,GAMlC,GAAGnC,EAAOsC,MAAMN,GACZ,OAAOA,GAMnB,OAAOhC,EAAOW,SAASxF,IAK3B6E,EAAOsC,MAAQ,SAASN,EAAOO,GAY3B,IAAIC,EAASxC,EAAOyC,eAAeT,GACnC,IAAc,IAAXQ,EACC,MAAMA,EAIV,IAAIN,EAAY,EAChB,IAAI,IAAIjB,KAAKe,EACNA,EAAMf,KAAOjB,EAAOS,YAAcT,EAAO0C,IAAIV,EAAMf,GAAIjB,EAAOG,WAC3D+B,EAGV,GAAGA,EAlLU,GAoLT,KAAM,uCAIVK,EAAUA,IAAW,EAErB,IAAIrB,EAAalB,EAAOmB,oBAAoBa,GACxCW,EAAS3C,EAAO4C,QAAQ1B,EAAYqB,GAExC,GAAGI,EAAO,CACN,IAAIE,EAAW,GACf,IAAI,IAAItB,KAAUoB,EACdE,GAAYF,EAAOpB,GAEvB,OAAOsB,EAEX,OAAO,GAGX7C,EAAO8C,eAAiB,SAASd,GAS7B,IAAIQ,EAASxC,EAAOyC,eAAeT,GACnC,IAAc,IAAXQ,EACC,MAAMA,EAIV,IAAIO,EAAiB/C,EAAOmB,oBAAoBa,GAGhD,IAAIe,EACA,OAAO,EAIX,IAAIvG,EAAO,GACPwG,EAAU,GACV/B,EAAI,EACR,IAAI,IAAIM,KAAUwB,EAAe,CAC7B,IAAI7B,EAAa6B,EAAexB,GAChCyB,EAAQlB,KAAKZ,GACVD,EAAI,IAAM,IACTzE,EAAKsF,KAAKkB,GACVA,EAAU,MAEZ/B,EAEN,OAAOzE,GAGXwD,EAAOmB,oBAAsB,SAASa,GAOlC,IAAIQ,EAASxC,EAAOyC,eAAeT,GACnC,IAAc,IAAXQ,EACC,MAAMA,EAGV,IAAIS,EAAgB,GAChBC,EAAqBlD,EAAOmD,qBAAqBnB,GAGrD,IAAI,IAAIV,KAAMlB,EACV6C,EAAc7C,EAAQkB,IAAOtB,EAAOG,OAKxC,IAAI,IAAIoB,KAAU2B,EAAmB,CACjC,IAAIE,EAAMF,EAAmB3B,GAE7B,GAAGvB,EAAO0C,IAAIU,EAAKpD,EAAOG,QAItB,IAHqBH,EAAO4B,QAAQqB,EAAe1B,EAAQ6B,GAIvD,OAAO,EAKnB,OAAOH,GAGXjD,EAAO4C,QAAU,SAAS1B,EAAYqB,GAOlC,IAAIrB,EACA,OAAO,EAIXqB,EAAUA,IAAW,EAIrB,IAAIc,EAAoB,EAGxB,IAAI,IAAI/B,KAAMlB,EAAQ,CAClB,IAAImB,EAASnB,EAAQkB,GAEjBgC,EAAgBpC,EAAWK,GAAQG,OAEpC4B,EAAgBD,IACfA,EAAoBC,EAEI/B,GAGhC,GAAyB,IAAtB8B,EACC,OAAOnC,EAIX,IAAIqC,EAAoB,GACpBC,EAAwB,KAC5B,IAAIlC,KAAMlB,GAGNkD,EAAgBpC,EAFhBK,EAASnB,EAAQkB,IAEkBI,QAEhB6B,GAAqBD,EAAgB,IACpDC,EAAoBD,EACpBE,EAAwBjC,GAQhC,IAAIkC,EAAiBvC,EAAWsC,GAChC,GAAIjB,GAiBA,IAAImB,EAAKD,EAAe/B,OAAS,EAAGgC,GAAM,IAAKA,EAU3C,GATAN,EAAMK,EAAeC,GAGrBC,EAAkBC,KAAKC,MAAMD,KAAKE,UAAU5C,IAC5C6C,EAAkB/D,EAAO4C,QACrB5C,EAAO4B,QAAQ+B,EAAiBH,EAAuBJ,GACvDb,GAIA,OAAOwB,OA3Bf,IAAI,IAAIL,KAAMD,EAAe,CACzB,IAAIL,EAAMK,EAAeC,GAGrBC,EAAkBC,KAAKC,MAAMD,KAAKE,UAAU5C,IAC5C6C,EAAkB/D,EAAO4C,QACzB5C,EAAO4B,QAAQ+B,EAAiBH,EAAuBJ,IAG3D,GAAGW,EACC,OAAOA,EAwBnB,OAAO,GAGX/D,EAAO4B,QAAU,SAASV,EAAYK,EAAQ6B,GAS1C,IAAIY,EAAa9C,EAAWK,GAAQ0C,QAAQb,EAAK,IAKjD,IAAI,IAAIc,KAAOF,EAAW,CACtB,IAAIG,EAAYH,EAAWE,GAK3B,IAFIlE,EAAOoE,WAAWlD,EAAYK,EAAQ4C,GAItC,OAAO,EAIf,OAAOjD,GAGXlB,EAAOoE,WAAa,SAASlD,EAAYK,EAAQ6B,GAU7C,IAAIpD,EAAO0C,IAAIU,EAAKlC,EAAWK,IAC3B,OAAOL,EAIXA,EAAWK,GAAUL,EAAWK,GAAQ0C,QAAQb,EAAK,IAIrD,IAAIE,EAAgBpC,EAAWK,GAAQG,OACvC,GAAqB,IAAlB4B,EAAoB,CACnB,IAAIe,EAAanD,EAAWK,GAE5B,IAAI,IAAI+C,KAAM/D,EAAiBgB,GAAQ,CACnC,IAAIgD,EAAOhE,EAAiBgB,GAAQ+C,GAEhCE,EACIxE,EAAOoE,WAAWlD,EAAYqD,EAAMF,GAE5C,IAAIG,EACA,OAAO,GAMjB,GAAqB,IAAlBlB,EACD,OAAO,EAIX,IAAI,IAAImB,KAAMnE,EAAiBiB,GAAQ,CACnC,IAAImD,EAAOpE,EAAiBiB,GAAQkD,GAEhCE,EAAa,GACjB,IAAI,IAAIrD,KAAMoD,EAAK,CACf,IAAIE,EAAcF,EAAKpD,GACpBtB,EAAO0C,IAAIU,EAAKlC,EAAW0D,KAC1BD,EAAW7C,KAAK8C,GAMxB,GAAyB,IAAtBD,EAAWjD,OACV,OAAO,EAGJ,GAAyB,IAAtBiD,EAAWjD,UACjB8C,EACIxE,EAAO4B,QAAQV,EAAYyD,EAAW,GAAIvB,IAG1C,OAAO,EAKnB,OAAOlC,GAQXlB,EAAOmD,qBAAuB,SAASnB,GAGnC,IAAI6C,EAAmB,GAGvB,GAAG7C,EAAMN,SAAWtB,EAAQsB,OAExB,KAAM,iCAGN,IAAI,IAAIT,KAAKb,EACTyE,EAAiBzE,EAAQa,IAAMe,EAAMf,GAI7C,OAAO4D,GAGX7E,EAAO8E,sBAAwB,SAASC,EAASC,GAG7C,IAAIC,EAAkB,GAGtB,IAAI,IAAI3D,KAAMyD,EAAQ,CAClB,IAAIG,EAAaH,EAAQzD,GAGrB6D,EAAmB,GAIvB,IAAI,IAAIV,KAAMO,EAAM,CAChB,IAAII,EAAWJ,EAAMP,IAEgB,IAAlCW,EAASC,QAAQH,IAChBC,EAAiBrD,KAAKsD,GAK9BH,EAAgBC,GAAcC,EAGlC,OAAOF,GAGXjF,EAAOsF,sBAAwB,SAASP,EAASQ,GAI7C,IAAIC,EAAmB,GAGvB,IAAI,IAAIlE,KAAMyD,EAAQ,CAClB,IAAIG,EAAaH,EAAQzD,GACrB6D,EAAmBI,EAAUL,GAG7BO,EAAmB,GAGvB,IAAI,IAAIC,KAAOP,EAAiB,CAC5B,IAAIC,EAAWD,EAAiBO,GAEhC,IAAI,IAAIjB,KAAMW,EAAS,CACnB,IAAIO,EAAkBP,EAASX,IAEmB,IAA/CgB,EAAiBJ,QAAQM,IACpBA,IAAoBT,GACxBO,EAAiB3D,KAAK6D,IAMlCH,EAAiBN,GAAcO,EAGnC,OAAOD,GAGXxF,EAAO4F,eAAiB,SAASpJ,EAAMqJ,GAGnC,IAAIb,EAAQ,GAGZ,IAAI,IAAIc,KAAMtJ,EACVwI,EAAMlD,KAAK9B,EAAO+F,OAAOvJ,EAAKsJ,GAAKD,IAIvC,IAAI,IAAIG,KAAMH,EACXb,EAAMlD,KAAK9B,EAAO+F,OAAOvJ,EAAMqJ,EAAKG,KAIvC,IAAIC,EAAc,CAAC,MAAO,MAAO,OAC7BC,EAAc,CAAC,MAAO,MAAO,OACjC,IAAI,IAAIC,KAAOF,EACX,IAAI,IAAIG,KAAOF,EACXlB,EAAMlD,KAAK9B,EAAO+F,OAAOE,EAAYE,GAAMD,EAAYE,KAI/D,OAAOpB,GAMXhF,EAAOqG,qBAAuB,SAASC,GAGnC,IAAI9J,EAAO,GACPwG,EAAU,GACd,IAAI,IAAI/B,KAAKqF,EACTtD,EAAQlB,KAAKwE,EAAarF,IACvBA,EAAI,IAAM,IACTzE,EAAKsF,KAAKkB,GACVA,EAAU,IAGlB,OAAOxG,GAGXwD,EAAOuG,qBAAuB,SAASC,GAInC,IADA,IAAIF,EAAe,GACXG,EAAI,EAAGA,EAAI,IAAKA,EACpB,IAAI,IAAIC,EAAI,EAAGA,EAAI,IAAKA,EACpBJ,GAAgBE,EAAWC,GAAGC,GAGtC,OAAOJ,GAOXtG,EAAO2G,YAAc,SAAS3E,GAK1B,IAAIQ,EAASxC,EAAOyC,eAAeT,GACnC,IAAc,IAAXQ,EACC,MAAMA,EAGV,IAMIoE,EAAiB,GAErB,IAAI,IAAI3F,KAAKe,EAAM,CAIf4E,GAHa5E,EAAMf,GATP,IAeTA,EAAI,IAAM,IACT2F,GAbY,MAiBb3F,EAAI,IAAM,IACT2F,GApBQ,MAwBT3F,EAAI,KAAO,KACV2F,GAtBY,MA0BpBC,QAAQC,IAAIF,IAGhB5G,EAAOyC,eAAiB,SAAST,GAM7B,IAAIA,EACA,MAAO,cAIX,GA5pBa,KA4pBVA,EAAMN,OACL,MAAO,wDAKX,IAAI,IAAIT,KAAKe,EACT,IAAIhC,EAAO0C,IAAIV,EAAMf,GAAIjB,EAAOG,SAAW6B,EAAMf,KAAOjB,EAAOS,WAC3D,MAAO,gDAAkDQ,EACjD,KAAOe,EAAMf,GAK7B,OAAO,GAGXjB,EAAO+F,OAAS,SAASgB,EAAGC,GAKxB,IAAIrE,EAAS,GACb,IAAI,IAAIsE,KAAMF,EACV,IAAI,IAAIG,KAAMF,EACVrE,EAAOb,KAAKiF,EAAEE,GAAMD,EAAEE,IAG9B,OAAOvE,GAGX3C,EAAO0C,IAAM,SAASyE,EAAGC,GAGrB,OAA2B,IAApBA,EAAI/B,QAAQ8B,IAGvBnH,EAAOqH,YAAc,SAASD,GAI1B,IAAI,IAAInG,KAAKmG,EACT,GAAGA,EAAInG,GACH,OAAOmG,EAAInG,GAGnB,OAAO,GAGXjB,EAAOqB,SAAW,SAAS+F,GAMvB,IADA,IAAIE,EAAW,GACPrG,EAAI,EAAGA,EAAImG,EAAI1F,SAAUT,EAC7BqG,EAASxF,MAAK,GAGlB,IAAIb,KAAKmG,EAAI,CAGT,IAFA,IAAIG,EAAKvH,EAAOyB,YAAY2F,EAAI1F,QAE1B4F,EAASC,IACXA,EAAMA,EAAK,EAAMH,EAAI1F,OAAS,EAAK,EAAK6F,EAAK,EAGjDD,EAASC,GAAMH,EAAInG,GAGvB,OAAOqG,GAGXtH,EAAOyB,YAAc,SAAS+F,EAAKC,GAM/B,GADAA,EAAMA,GAAO,EACVD,EACC,OAAOE,KAAKC,MAAMD,KAAKE,UAAYJ,EAAMC,IAAQA,EAGjD,KAAM,mBAIdzH,EAAO+B,YAAc,SAASqF,GAG1B,IAAIS,EAAU,GACVC,EAAU,GACd,IAAI,IAAI7G,KAAKmG,EAAI,CACb,IAAIW,EAAIX,EAAInG,GACR6G,EAAQC,KACRF,EAAQ/F,KAAKiG,GACbD,EAAQC,IAAK,GAGrB,OAAOF,GAGX7H,EAAOc,aAAe,SAASkH,EAAIR,EAAKC,GAOpC,OADAO,EAAKA,GAAM,IADXP,EAAMA,GAAO,GAGFA,EAERO,EAAKR,EACGA,EAEJQ,GAvvBP5H,EAAsBJ,EAAO+F,OAAO9F,EAAMC,GAC1CG,EAAsBL,EAAO4F,eAAe3F,EAAMC,GAClDI,EAAsBN,EAAO8E,sBAAsB1E,EAASC,GAC5DE,EAAsBP,EAAOsF,sBAAsBlF,EACvBE,GAyvBzB,IC7tBP2H,EAAY,CAAE,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IACxC,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IACxC,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IACxC,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IACxC,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IACxC,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IACxC,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IACxC,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IACxC,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAyB1D,SAASC,EAAgBC,EAAaC,GAAe,IAAD,EApBpD,SAAuBD,GAErB,OAAOA,GACL,KAAK,EAAG,MAAO,CAAC,EAAE,GAClB,KAAK,EAAG,MAAO,CAAC,EAAE,GAClB,KAAK,EAAG,MAAO,CAAC,EAAE,GAClB,KAAK,EAAG,MAAO,CAAC,EAAE,GAClB,KAAK,EAAG,MAAO,CAAC,EAAE,GAClB,KAAK,EAAG,MAAO,CAAC,EAAE,GAClB,KAAK,EAAG,MAAO,CAAC,EAAE,GAClB,KAAK,EAAG,MAAO,CAAC,EAAE,GAClB,QAAS,MAAO,CAAC,EAAE,IAUDE,CAAcF,GADgB,mBAC7CzL,EAD6C,KACxCC,EADwC,KAGlD,OAAOyL,GACL,KAAK,EAAI1L,IAAOC,IAAU,MAC1B,KAAK,EAAID,IAAO,MAChB,KAAK,EAAIA,IAAOC,IAAU,MAC1B,KAAK,EAAIA,IAAU,MACnB,KAAK,EAAI,MACT,KAAK,EAAIA,IAAU,MACnB,KAAK,EAAID,IAAOC,IAAU,MAC1B,KAAK,EAAID,IAAO,MAChB,KAAK,EAAIA,IAAOC,IAElB,OAAa,EAAND,EAAUC,EAMnB,SAAS2L,EAAeC,EAAyBJ,EAAa/L,GAC5D,MAAsD,MAA/CmM,EAAcL,EAAgBC,EAAK/L,IAAkB,EAAI,EAgF3D,IAAMoM,EAAkB,SAACrN,EAAoB4M,GAClD,IAAIU,EAAqBR,EAAUS,QAC/BC,EAAuBV,EAAUS,QACjC1I,EDqlBOA,EChlBP4I,EAAM5I,EAAOW,SAAS,IAqB1B,OAnBA,YAAIiI,GAAKC,SAAQ,SAACzM,EAAO0M,GACvBL,EAAmBK,GAAmB,MAAV1M,EACN,IACAA,KAMxBwM,EAAM5I,EAAOsC,MAAMsG,GACnB,YAAIA,GAAKC,SAAQ,SAACzM,EAAO0M,GACvBH,EAAqBG,GAAS1M,KAQzB,CAFPqM,EArGF,SAA+BM,EAAuB5N,EAAoB4M,GACxE,IACIiB,EAAcC,EAAcC,EAAYf,EADxCgB,EAAoBhO,EAGpBoN,EAAgBN,EAAUS,QAC1BU,EAAY,CAAE,EAAE,EAAE,EACJ,EAAE,EAAE,EACJ,EAAE,EAAE,GAClBC,EAAiB,GACjBC,EAAiB,GAEjBvB,IACFoB,EAAoBpB,EAAE5F,OAAO/F,OAEL,SAAtB+M,GACFH,EAAe,EACfC,EAAe,EACfC,EAAa,IAEgB,WAAtBC,GACPH,EAAe,EACfC,EAAe,EACfC,EAAa,KAGbF,EAAe,EACfC,EAAe,EACfC,EAAa,IAGf,IAAK,IAAIK,EAAI,EAAGA,EAAI,EAAGA,IACrBH,EAAUG,GAAMjB,EAAeC,EAAegB,EAAG,GACjCjB,EAAeC,EAAegB,EAAG,GACjCjB,EAAeC,EAAegB,EAAG,GACjCjB,EAAeC,EAAegB,EAAG,GACjCjB,EAAeC,EAAegB,EAAG,GACjCjB,EAAeC,EAAegB,EAAG,GACjCjB,EAAeC,EAAegB,EAAG,GACjCjB,EAAeC,EAAegB,EAAG,GACjCjB,EAAeC,EAAegB,EAAG,GAGnD,IAAK,IAAItI,EAAI,EAAGA,EAAIiI,EAAYjI,IAAK,CACnCoI,EAAiB,GACjB,IAAK,IAAIE,EAAI,EAAGA,EAAI,EAAGA,IACjBH,EAAUG,GAAKP,GACjBK,EAAevH,KAAKyH,GAGxB,GAAIF,EACF,IAAK,IAAIE,EAAI,EAAGA,EAAI,EAAGA,IACjBH,EAAUG,GAAKN,GACjBI,EAAevH,KAAKyH,GAI1BpB,EAAMkB,EAAe3B,KAAKE,SAAWyB,EAAe3H,OAAS,GAE7D4H,EAAiB,GACjB,IAAK,IAAIC,EAAI,EAAGA,EAAI,EAAGA,IAC2B,MAA3ChB,EAAcL,EAAgBC,EAAKoB,KACtCD,EAAexH,KAAKyH,GAKxB,IAAIT,EAAQZ,EAAgBC,EAFrBmB,EAAe5B,KAAKE,SAAW0B,EAAe5H,OAAS,IAG9D6G,EAAcO,GAASC,EAAYD,GACnCM,EAAUjB,KAGZ,OAAOI,EA8BciB,CAAsBb,EAAsBxN,EAAY4M,GAEjDY,ICpOjBc,EAAqB,WAAM,MAuBrBpN,IAPXtB,EAhBgC,EAgBhCA,eAAgBC,EAhBgB,EAgBhBA,kBAChBC,EAjBgC,EAiBhCA,UAAWC,EAjBqB,EAiBrBA,aACXC,EAlBgC,EAkBhCA,WAAYC,EAlBoB,EAkBpBA,cACZG,EAnBgC,EAmBhCA,mBACAC,EApBgC,EAoBhCA,SAAUC,EApBsB,EAoBtBA,YACVC,EArBgC,EAqBhCA,aAAcC,EArBkB,EAqBlBA,gBACdC,EAtBgC,EAsBhCA,UAAWC,EAtBqB,EAsBrBA,aACXE,EAvBgC,EAuBhCA,OAvBgC,EAwBEG,oBAAkB,GAxBpB,mBAwBhCwN,EAxBgC,KAwBlBC,EAxBkB,OAyBRzN,mBAAqB,IAzBb,mBAyBhC0N,EAzBgC,KAyBvBC,EAzBuB,OA0BA3N,mBAAmB,IA1BnB,mBA0BhC6M,EA1BgC,KA0BnBe,EA1BmB,OA2BR5N,oBAAkB,GA3BV,mBA2BhC6N,EA3BgC,KA2BvBC,EA3BuB,KAgCtC,SAASC,EAAelC,GAA2C,IAAD,EACbS,EAAgBrN,EAAY4M,GADf,mBAC1DU,EAD0D,KACtCE,EADsC,KAGhE9M,EAAa4M,GACbvN,EAAauN,GACbqB,EAAenB,GACf3N,EAAkB,KAClBO,EAAmBD,OACnBK,GAAiB,GACjBkO,EAAW,IACX9N,GAAO,GAsBT,SAASmO,EAAUpB,EAAe1M,GAChC,GAAyB,MAArBR,EAAUkN,GAAgB,CAE5B,IAAIqB,EAAYlP,EAAUyN,QACtB0B,EAAcR,EAAQlB,QAG1B0B,EAAYtI,KAAK7G,EAAUyN,SAC3BmB,EAAWO,GAEXD,EAAUrB,GAAS1M,EACnBlB,EAAaiP,GA3BjB,SAAmBrB,EAAe1M,GAChC,QAAInB,EAAUoP,OAAM,SAACjC,EAAckC,GAC7B,OAAIA,IAAcxB,EACT1M,IAAU2M,EAAYuB,GAEtBlC,IAASW,EAAYuB,MAwB9BC,CAAUzB,EAAO1M,KACnB4N,GAAW,GACXjO,GAAO,KASb,SAASyO,EAAc1B,EAAe1M,GAChCsN,EACEtN,IAAU2M,EAAYD,IACxBoB,EAAUpB,EAAO1M,GAMnB8N,EAAUpB,EAAO1M,GAgHrB,OALAoB,qBAAU,WACRyM,MAEC,IAGD,qCACE,sBAAKtP,UAAWoP,EAAQ,iBAAiB,YAAzC,UACE,cAAC,EAAD,CAAQnP,QA3Gd,WACEqP,OA2GI,sBAAKtP,UAAU,iBAAf,UACE,cAAC,EAAD,CACEC,QAAS,SAACiC,GAAD,OAvGnB,SAAqBA,GACfrB,GAA+B,MAAnBT,GACdyP,EAAc3N,EAAc9B,GAE9BY,EAAgBkB,GAmG2B4N,CAAY5N,MAEjD,cAAC,EAAD,CACEsB,cAAe,SAACC,GAAD,OArFzB,SAAuBA,GACjB5C,EACFR,EAAkBoD,IACS,IAAlB1C,GACT8O,EAAc9O,EAAa0C,GAiFcD,CAAcC,IACjDhB,SAAU,SAAC2K,GAAD,OA/FpB,SAA4BA,GAC1B3M,EAAc2M,EAAE5F,OAAO/F,OACvB6N,EAAelC,GA6FgD2C,CAAmB3C,IAC1EtI,YA3EV,WACE,GAAGmK,EAAQlI,OAAQ,CACjB,IAAI0I,EAAcR,EAAQlB,QACtByB,EAAYC,EAAYO,MAC5Bd,EAAWO,QACOQ,IAAdT,GACFjP,EAAaiP,KAsETzK,aA9DV,YACuB,IAAlBhE,GAAmD,MAA5BT,EAAUS,IAClCwO,EAAUxO,EAAc,MA6DlBiE,YArDV,YACwB,IAAlBjE,GACFwO,EAAUxO,EAAcqN,EAAYrN,KAoD9BkE,oBA7CV,WACE+J,GAAiBD,IA6CT7J,gBAvCV,WACMrE,GACFR,EAAkB,KAEpBW,GAAiB,GACjBF,GAAaD,SAqCT,cAAC,EAAD,OAEF,qBAAKb,UAAaoP,EACE,2BACA,UAEfnP,QArCT,WACEoP,GAAW,GACXC,KA+BE,SAME,qBAAItP,UAAU,gBAAd,iBACM,sBAAMA,UAAU,qBAAhB,oBADN,IACyD,sBAAMA,UAAU,qBAAhB,0BChPpDkQ,G,MAAoB,WAC/B,OACE,cAAC,EAAD,UACE,cAAC,EAAD,QCPNC,iBAAO,cAAC,EAAD,IAASC,SAASC,eAAe,W","file":"static/js/main.4ac4d2f6.chunk.js","sourcesContent":["import React from 'react';\n\ntype HeaderProps = {\n  onClick: () => void\n};\n\n/**\n * React component for the Header Section.\n */\nexport const Header = (props: HeaderProps) => {\n  return (\n    <header className=\"header\">\n      <h1>\n        Su<span className=\"header__group-one\">do</span><span className=\"header__group-two\">ku</span>\n      </h1>\n      <h2 onClick={props.onClick}>\n        New Game\n      </h2>\n    </header>\n  )\n}\n","import React, { createContext, useContext, useState } from 'react';\nimport moment from 'moment';\n\ntype SudokuContextProps = {\n  numberSelected: string,\n  setNumberSelected: React.Dispatch<React.SetStateAction<string>>,\n  gameArray: string[],\n  setGameArray: React.Dispatch<React.SetStateAction<string[]>>,\n  difficulty: string,\n  setDifficulty: React.Dispatch<React.SetStateAction<string>>,\n  timeGameStarted: moment.Moment,\n  setTimeGameStarted: React.Dispatch<React.SetStateAction<moment.Moment>>,\n  fastMode: boolean,\n  setFastMode: React.Dispatch<React.SetStateAction<boolean>>,\n  cellSelected: number,\n  setCellSelected: React.Dispatch<React.SetStateAction<number>>,\n  initArray: string[],\n  setInitArray: React.Dispatch<React.SetStateAction<string[]>>,\n  won: boolean,\n  setWon: React.Dispatch<React.SetStateAction<boolean>>\n};\n\n\nconst SudokuContext = createContext<SudokuContextProps>({ numberSelected: '0', setNumberSelected: () => {},\n                                                          gameArray: [], setGameArray: () => {},\n                                                          difficulty: 'Easy', setDifficulty: () => {},\n                                                          timeGameStarted: moment(), setTimeGameStarted: () => {},\n                                                          fastMode: false, setFastMode: () => {},\n                                                          cellSelected: -1, setCellSelected: () => {},\n                                                          initArray: [], setInitArray: () => {},\n                                                          won: false, setWon: () => {} });\n\ntype SudokuProviderProps = {\n  children: React.ReactElement\n};\n\nexport const SudokuProvider = ({ children }: SudokuProviderProps) => {\n  let [ numberSelected, setNumberSelected ] = useState<string>('0');\n  let [ gameArray, setGameArray ] = useState<string[]>([]);\n  let [ difficulty,setDifficulty ] = useState<string>('Easy');\n  let [ timeGameStarted, setTimeGameStarted ] = useState<moment.Moment>(moment());\n  let [ fastMode, setFastMode ] = useState<boolean>(false);\n  let [ cellSelected, setCellSelected ] = useState<number>(-1);\n  let [ initArray, setInitArray ] = useState<string[]>([]);\n  let [ won, setWon ] = useState<boolean>(false);\n\n  return (\n    <SudokuContext.Provider value={\n      {\n        numberSelected, setNumberSelected,\n        gameArray, setGameArray,\n        difficulty,setDifficulty,\n        timeGameStarted, setTimeGameStarted,\n        fastMode, setFastMode,\n        cellSelected, setCellSelected,\n        initArray, setInitArray,\n        won, setWon\n      }\n    }>\n      {children}\n    </SudokuContext.Provider>\n  );\n};\n\nexport const useSudokuContext = (): SudokuContextProps => useContext(SudokuContext);\n\n// Usage\n// const { numberSelected, setNumberSelected } = useNumberValue();\n","import React from 'react';\nimport { useSudokuContext } from '../../context/SudokuContext';\n\ntype GameSectionProps = {\n  onClick: (indexOfArray: number) => void\n};\n\n/**\n * React component for the Game Section\n */\nexport const GameSection = (props: GameSectionProps) => {\n  const rows = [0,1,2,3,4,5,6,7,8];\n  let { numberSelected,\n        gameArray,\n        fastMode,\n        cellSelected,\n        initArray } = useSudokuContext();\n\n  /**\n   * Cell Highlight Method 1: Highlight all cells\n   * related to current cell. By related, I mean all\n   * cells in the same row/column/box as the current cell.\n   */\n  // eslint-disable-next-line\n  function _isCellRelatedToSelectedCell(row: number, column: number) {\n    if (cellSelected === row * 9 + column) {\n      return true;\n    }\n    let rowOfSelectedCell = Math.floor(cellSelected / 9);\n    let columnOfSelectedCell = cellSelected % 9;\n    if (rowOfSelectedCell === row || columnOfSelectedCell === column) {\n      return true;\n    }\n    return [  [0,3,0,3],\n              [0,3,3,6],\n              [0,3,6,9],\n              [3,6,0,3],\n              [3,6,3,6],\n              [3,6,6,9],\n              [6,9,0,3],\n              [6,9,3,6],\n              [6,9,6,9]\n            ].some((array) => {\n              if (rowOfSelectedCell > array[0]-1 && row > array[0]-1 &&\n                  rowOfSelectedCell < array[1] && row < array[1] &&\n                  columnOfSelectedCell > array[2]-1 && column > array[2]-1 &&\n                  columnOfSelectedCell < array[3] && column < array[3])\n                  return true;\n              return false;\n            });\n  }\n\n  /**\n   * Cell Highlight Method 2: Highlight all cells with\n   * the same number as in the current cell.\n   */\n  function _isCellSameAsSelectedCell(row: number, column: number) {\n    if (fastMode) {\n      if (numberSelected === gameArray[row * 9 + column]) {\n        return true;\n      }\n      return false;\n    } else {\n      if (cellSelected === row * 9 + column) {\n        return true;\n      }\n      if (gameArray[cellSelected] === '0') {\n        return false;\n      }\n      if (gameArray[cellSelected] === gameArray[row * 9 + column]) {\n        return true;\n      }\n    }\n  }\n\n  /**\n   * Returns the classes for a cell related to the selected cell.\n   */\n  function _selectedCell(indexOfArray: number, value: string, highlight: string) {\n    if (value !== '0') {\n      if (initArray[indexOfArray] === '0') {\n        return (\n          <td className={`game__cell game__cell--userfilled game__cell--${highlight}selected`} key={indexOfArray} onClick={() => props.onClick(indexOfArray)}>{value}</td>\n        )\n      } else {\n        return (\n          <td className={`game__cell game__cell--filled game__cell--${highlight}selected`} key={indexOfArray} onClick={() => props.onClick(indexOfArray)}>{value}</td>\n        )\n      }\n    } else {\n      return (\n        <td className={`game__cell game__cell--${highlight}selected`} key={indexOfArray} onClick={() => props.onClick(indexOfArray)}>{value}</td>\n      )\n    }\n  }\n\n  /**\n   * Returns the classes or a cell not related to the selected cell.\n   */\n  function _unselectedCell(indexOfArray: number, value: string) {\n    if (value !== '0') {\n      if (initArray[indexOfArray] === '0') {\n        return (\n          <td className=\"game__cell game__cell--userfilled\" key={indexOfArray} onClick={() => props.onClick(indexOfArray)}>{value}</td>\n        )\n      } else {\n        return (\n          <td className=\"game__cell game__cell--filled\" key={indexOfArray} onClick={() => props.onClick(indexOfArray)}>{value}</td>\n        )\n      }\n    } else {\n      return (\n        <td className=\"game__cell\" key={indexOfArray} onClick={() => props.onClick(indexOfArray)}>{value}</td>\n      )\n    }\n  }\n\n  return (\n    <section className=\"game\">\n      <table className=\"game__board\">\n        <tbody>\n          {\n            rows.map((row) => {\n              return (\n                <tr className=\"game__row\" key={row}>\n                  {\n                    rows.map((column) => {\n                      const indexOfArray = row * 9 + column;\n                      const value = gameArray[indexOfArray];\n\n                      if (cellSelected === indexOfArray) {\n                        return _selectedCell(indexOfArray, value, 'highlight');\n                      }\n\n                      if (fastMode) {\n                        if (numberSelected !== '0' && _isCellSameAsSelectedCell(row, column)) {\n                          return _selectedCell(indexOfArray, value, '');\n                        } else {\n                          return _unselectedCell(indexOfArray, value);\n                        }\n                      } else {\n                        if (cellSelected !== -1 && _isCellSameAsSelectedCell(row, column)) {\n                          return _selectedCell(indexOfArray, value, '');\n                        } else {\n                          return _unselectedCell(indexOfArray, value);\n                        }\n                      }\n                    })\n                  }\n                </tr>\n              )\n            })\n          }\n        </tbody>\n      </table>\n    </section>\n  )\n}\n","import React from 'react';\nimport { useSudokuContext } from '../context/SudokuContext';\n\ntype DifficultyProps = {\n  onChange: (e: React.ChangeEvent<HTMLSelectElement>) => void\n};\n\n/**\n * React component for the Difficulty Selector.\n */\nexport const Difficulty = (props: DifficultyProps) => {\n  let { difficulty } = useSudokuContext();\n\n  return (\n    <div className=\"status__difficulty\">\n      <span className=\"status__difficulty-text\">Difficulty:&nbsp;&nbsp;</span>\n      <select name=\"status__difficulty-select\" className=\"status__difficulty-select\" defaultValue={difficulty} onChange={props.onChange}>\n        <option value=\"Easy\">Easy</option>\n        <option value=\"Medium\">Medium</option>\n        <option value=\"Hard\">Hard</option>\n      </select>\n    </div>\n  )\n}\n","import React, { useState, useEffect } from 'react';\nimport { useSudokuContext } from '../context/SudokuContext';\nimport moment from 'moment';\n\n/**\n * React component for the Timer in Status Section.\n * Uses the 'useEffect' hook to update the timer every minute.\n */\nexport const Timer = () => {\n  let [currentTime, setCurrentTime] = useState(moment());\n  let { timeGameStarted, won } = useSudokuContext();\n\n  useEffect(() => {\n    if (!won)\n      setTimeout(() => tick(), 1000);\n  });\n\n  function tick() {\n    setCurrentTime(moment());\n  }\n\n  function getTimer() {\n    let secondsTotal = currentTime.diff(timeGameStarted, 'seconds');\n    if (secondsTotal <= 0)\n      return '00:00';\n    let duration = moment.duration(secondsTotal, 'seconds');\n    let hours = duration.hours();\n    let minutes = duration.minutes();\n    let seconds = duration.seconds();\n    let stringTimer = '';\n\n    stringTimer += hours ? '' + hours + ':' : '';\n    stringTimer += minutes ? (minutes < 10 ? '0' : '') + minutes + ':' : '00:';\n    stringTimer += seconds < 10 ? '0' + seconds : seconds;\n\n    return stringTimer;\n  }\n\n  return (\n    <div className=\"status__time\">{getTimer()}\n    </div>\n  )\n}\n","import React from 'react';\nimport { useSudokuContext } from '../context/SudokuContext';\n\ntype NumbersProps = {\n  onClickNumber: (number: string) => void\n};\n\n/**\n * React component for the Number Selector in the Status Section.\n */\nexport const Numbers = ({ onClickNumber } : NumbersProps) => {\n  let { numberSelected } = useSudokuContext();\n\n  return (\n    <div className=\"status__numbers\">\n      {\n        [1,2,3,4,5,6,7,8,9].map((number) => {\n          if (numberSelected === number.toString()) {\n            return (\n              <div className=\"status__number status__number--selected\" key={number} onClick={() => onClickNumber(number.toString())}>{number}</div>\n            )\n          } else {\n            return (\n              <div className=\"status__number\" key={number} onClick={() => onClickNumber(number.toString())}>{number}</div>\n            )\n          }\n        })\n      }\n    </div>\n  )\n}\n","import React from 'react';\n\ntype ActionProps = {\n  action: string,\n  onClickAction: () => void\n};\n\ntype SvgProps = {\n  action: string\n};\n\n/**\n * Return the SVGs of the Action buttons in the Status Section.\n */\nconst Svg = (props: SvgProps) => {\n  if (props.action === 'undo') {\n    return (\n      <svg className=\"status__action-svg\" height=\"512pt\" viewBox=\"0 0 512 512\" width=\"512pt\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"m154.667969 213.332031h-138.667969c-8.832031 0-16-7.167969-16-16v-138.664062c0-8.832031 7.167969-16 16-16s16 7.167969 16 16v122.664062h122.667969c8.832031 0 16 7.167969 16 16s-7.167969 16-16 16zm0 0\" fill=\"hsl(213, 30%, 59%)\"/><path d=\"m256 512c-68.351562 0-132.628906-26.644531-180.96875-75.03125-6.253906-6.25-6.253906-16.382812 0-22.632812 6.269531-6.273438 16.402344-6.230469 22.632812 0 42.304688 42.347656 98.515626 65.664062 158.335938 65.664062 123.519531 0 224-100.480469 224-224s-100.480469-224-224-224c-105.855469 0-200.257812 71.148438-224.449219 169.171875-2.132812 8.597656-10.75 13.824219-19.371093 11.714844-8.574219-2.132813-13.800782-10.796875-11.710938-19.371094 27.691406-112.148437 135.148438-193.515625 255.53125-193.515625 141.164062 0 256 114.835938 256 256s-114.835938 256-256 256zm0 0\" fill=\"hsl(213, 30%, 59%)\"/></svg>\n    )\n  } else if (props.action === 'erase') {\n    return (\n      <svg className=\"status__action-svg\" version=\"1.1\" id=\"Layer_1\" xmlns=\"http://www.w3.org/2000/svg\" x=\"0px\" y=\"0px\" viewBox=\"0 0 512.001 512.001\"><path d=\"M505.922,476.567L285.355,256L505.92,35.435c8.106-8.105,8.106-21.248,0-29.354c-8.105-8.106-21.248-8.106-29.354,0L256.001,226.646L35.434,6.081c-8.105-8.106-21.248-8.106-29.354,0c-8.106,8.105-8.106,21.248,0,29.354L226.646,256L6.08,476.567c-8.106,8.106-8.106,21.248,0,29.354c8.105,8.105,21.248,8.106,29.354,0l220.567-220.567l220.567,220.567c8.105,8.105,21.248,8.106,29.354,0S514.028,484.673,505.922,476.567z\" fill=\"hsl(213, 30%, 59%)\"/></svg>\n    )\n  } else if (props.action === 'hint') {\n    return (\n      <svg className=\"status__action-svg\" version=\"1.1\" id=\"Capa_1\" xmlns=\"http://www.w3.org/2000/svg\" x=\"0px\" y=\"0px\" viewBox=\"0 0 432.4 432.4\">\n        <path d=\"M216.529,93.2c-61.2,0-111.2,50-111.2,111.2c0,32,14,62.8,37.6,83.6c17.6,17.6,16,55.2,15.6,55.6c0,2,0.4,3.6,2,5.2c1.2,1.2,3.2,2,4.8,2h102c2,0,3.6-0.8,4.8-2c1.2-1.2,2-3.2,2-5.2c0-0.4-2-38,15.6-55.6c0.4-0.4,0.8-0.8,1.2-1.2c23.2-21.2,36.8-51.2,36.8-82.4C327.729,143.2,277.729,93.2,216.529,93.2zM280.529,277.6c-0.4,0.4-1.2,1.2-1.2,1.6c-15.6,16.8-18.4,44.4-18.8,57.6h-88.4c-0.4-13.2-3.2-42-20-59.2c-21.2-18.4-33.6-45.2-33.6-73.6c0-54,43.6-97.6,97.6-97.6s97.6,43.6,97.6,97.6C313.729,232.4,301.729,259.2,280.529,277.6z\" fill=\"hsl(213, 30%, 59%)\"/>\n        <path d=\"M216.129,121.6c-3.6,0-6.8,3.2-6.8,6.8c0,3.6,3.2,6.8,6.8,6.8c40.4,0,72.8,32.8,72.8,72.8c0,3.6,3.2,6.8,6.8,6.8c3.6,0,6.8-3.2,6.8-6.8C302.929,160.4,264.129,121.6,216.129,121.6z\" fill=\"hsl(213, 30%, 59%)\"/>\n        <path d=\"M260.529,358.4h-88.8c-9.2,0-16.8,7.6-16.8,16.8s7.6,16.8,16.8,16.8h88.4c9.6-0.4,17.2-7.6,17.2-16.8C277.329,366,269.729,358.4,260.529,358.4zM260.529,378h-88.8c-1.6,0-3.2-1.2-3.2-3.2s1.2-3.2,3.2-3.2h88.4c1.6,0,3.2,1.2,3.2,3.2S262.129,378,260.529,378z\" fill=\"hsl(213, 30%, 59%)\"/>\n        <path d=\"M247.329,398.8h-62.4c-9.2,0-16.8,7.6-16.8,16.8s7.6,16.8,16.8,16.8h62.4c9.2,0,16.8-7.6,16.8-16.8C264.129,406,256.529,398.8,247.329,398.8zM247.329,418.4h-62.4c-1.6,0-3.2-1.2-3.2-3.2s1.2-3.2,3.2-3.2h62.4c1.6,0,3.2,1.2,3.2,3.2S248.929,418.4,247.329,418.4z\" fill=\"hsl(213, 30%, 59%)\"/>\n        <path d=\"M216.129,60c4,0,6.8-3.2,6.8-6.8V6.8c0-3.6-3.2-6.8-6.8-6.8c-3.6,0-6.8,3.2-6.8,6.8v46.4C209.329,56.8,212.529,60,216.129,60z\" fill=\"hsl(213, 30%, 59%)\"/>\n        <path d=\"M329.329,34.4c-3.2-2.4-7.2-1.2-9.2,1.6l-25.6,38.4c-2.4,3.2-1.6,7.6,1.6,9.6c1.2,0.8,2.4,1.2,3.6,1.2c2.4,0,4.4-1.2,5.6-3.2l25.6-38.4C333.329,40.8,332.529,36.4,329.329,34.4z\" fill=\"hsl(213, 30%, 59%)\"/>\n        <path d=\"M134.929,83.6c1.2,0,2.4-0.4,3.6-1.2c3.2-2,4-6.4,2-9.6l-24.8-38.8c-2-3.2-6.4-4-9.6-2s-4,6.4-2,9.6l24.8,38.8C130.529,82.8,132.529,83.6,134.929,83.6z\" fill=\"hsl(213, 30%, 59%)\"/>\n        <path d=\"M86.529,126l-40.4-22c-3.2-1.6-7.6-0.4-9.2,2.8c-2,3.2-0.8,7.6,2.8,9.2l40.4,22c1.2,0.4,2,0.8,3.2,0.8c2.4,0,4.8-1.2,6-3.6C90.929,132,89.729,127.6,86.529,126z\" fill=\"hsl(213, 30%, 59%)\"/>\n        <path d=\"M395.729,106.8c-1.6-3.2-6-4.4-9.2-2.8l-40.8,22c-3.2,1.6-4.4,6-2.8,9.2c1.2,2.4,3.6,3.6,6,3.6c1.2,0,2.4-0.4,3.2-0.8l40.8-22C396.129,114.4,397.329,110,395.729,106.8z\" fill=\"hsl(213, 30%, 59%)\"/>\n      </svg>\n    )\n  } else {\n    return null;\n  }\n}\n\n/**\n * React component for the Action buttons in the Status Section.\n */\nexport const Action = (props: ActionProps) => {\n  return (\n    <div className={  props.action === 'undo'\n                      ? \"status__action-undo\"\n                      : props.action === 'erase'\n                      ? \"status__action-erase\"\n                      : props.action === 'hint'\n                      ? \"status__action-hint\"\n                      : \"\"\n                    } onClick={props.onClickAction} >\n      <Svg action={props.action} />\n      <p className=\"status__action-text\">\n        {\n          props.action === 'undo'\n            ? 'Undo'\n            : props.action === 'erase'\n            ? 'Erase'\n            : props.action === 'hint'\n            ? 'Hint'\n            : ''\n        }</p>\n    </div>\n  )\n}\n","import React from 'react';\n\ntype ModeProps = {\n  mode: string,\n  onClickMode: () => void\n};\n\n/**\n * React component for the Mistakes Mode / Fast Mode\n * elements in the Status Section.\n */\nexport const Mode = (props: ModeProps) => {\n  return (\n    <div className={ props.mode === 'mistakes'\n                      ? \"status__action-mistakes-mode\"\n                      : \"status__action-fast-mode\"}>\n      <label className={ props.mode === 'mistakes'\n                          ? \"status__action-mistakes-mode-switch\"\n                          : \"status__action-fast-mode-switch\"}>\n        <input type=\"checkbox\" />\n        <span className={ props.mode === 'mistakes'\n                            ? \"status__action-mistakes-mode-slider\"\n                            : \"status__action-fast-mode-slider\"}\n              onClick={props.onClickMode}\n        ></span>\n      </label>\n      <p className=\"status__action-text\">{ props.mode === 'mistakes'\n                  ? 'Mistakes Mode'\n                  : 'Fast Mode'}</p>\n    </div>\n  )\n}\n","import React from 'react';\nimport { Difficulty } from '../Difficulty';\nimport { Timer } from '../Timer';\nimport { Numbers } from '../Numbers';\nimport { Action } from '../Action';\nimport { Mode } from '../Mode';\n\ntype StatusSectionProps = {\n  onChange: (e: React.ChangeEvent<HTMLSelectElement>) => void,\n  onClickNumber: (number: string) => void,\n  onClickUndo: () => void,\n  onClickErase: () => void,\n  onClickHint: () => void,\n  onClickMistakesMode: () => void,\n  onClickFastMode: () => void,\n};\n\n/**\n * React component for the Status Section.\n */\nexport const StatusSection = (props: StatusSectionProps) => {\n  return (\n    <section className=\"status\">\n      <Difficulty onChange={props.onChange} />\n      <Timer />\n      <Numbers onClickNumber={(number) => props.onClickNumber(number)} />\n      <div className=\"status__actions\">\n        <Action action='undo' onClickAction={props.onClickUndo} />\n        <Action action='erase' onClickAction={props.onClickErase} />\n        <Action action='hint' onClickAction={props.onClickHint} />\n        <Mode mode='mistakes' onClickMode={props.onClickMistakesMode} />\n        <Mode mode='fast' onClickMode={props.onClickFastMode} />\n      </div>\n    </section>\n  )\n}\n","import React from 'react';\n\n/**\n * React component for the Footer Section.\n */\nexport const Footer = () => {\n  return (\n    <footer className=\"footer\">\n      <p>&#169; 2020 Amith Raravi - source code on <a href=\"https://github.com/raravi/sudoku\">Github</a></p>\n    </footer>\n  )\n}\n","/*\n    Sudoku.js\n    ---------\n\n    A Sudoku puzzle generator and solver JavaScript library.\n\n    Please see the README for more details.\n*/\n\n//(function(root){\n    //var sudoku = root.sudoku = {};  // Global reference to the sudoku library\n    var sudoku = {};\n    sudoku.DIGITS = \"123456789\";    // Allowed sudoku.DIGITS\n    var ROWS = \"ABCDEFGHI\";         // Row lables\n    var COLS = sudoku.DIGITS;       // Column lables\n    var SQUARES = null;             // Square IDs\n\n    var UNITS = null;               // All units (row, column, or box)\n    var SQUARE_UNITS_MAP = null;    // Squares -> units map\n    var SQUARE_PEERS_MAP = null;    // Squares -> peers map\n\n    var MIN_GIVENS = 17;            // Minimum number of givens\n    var NR_SQUARES = 81;            // Number of squares\n\n    // Define difficulties by how many squares are given to the player in a new\n    // puzzle.\n    var DIFFICULTY = {\n        \"easy\":         62,\n        \"medium\":       53,\n        \"hard\":         44,\n        \"very-hard\":    35,\n        \"insane\":       26,\n        \"inhuman\":      17,\n    };\n\n    // Blank character and board representation\n    sudoku.BLANK_CHAR = '.';\n    sudoku.BLANK_BOARD = \"....................................................\"+\n            \".............................\";\n\n    // Init\n    // -------------------------------------------------------------------------\n    function initialize(){\n        /* Initialize the Sudoku library (invoked after library load)\n        */\n        SQUARES             = sudoku._cross(ROWS, COLS);\n        UNITS               = sudoku._get_all_units(ROWS, COLS);\n        SQUARE_UNITS_MAP    = sudoku._get_square_units_map(SQUARES, UNITS);\n        SQUARE_PEERS_MAP    = sudoku._get_square_peers_map(SQUARES,\n                                    SQUARE_UNITS_MAP);\n    }\n\n    // Generate\n    // -------------------------------------------------------------------------\n    sudoku.generate = function(difficulty, unique){\n        /* Generate a new Sudoku puzzle of a particular `difficulty`, e.g.,\n\n            // Generate an \"easy\" sudoku puzzle\n            sudoku.generate(\"easy\");\n\n\n        Difficulties are as follows, and represent the number of given squares:\n\n                \"easy\":         61\n                \"medium\":       52\n                \"hard\":         43\n                \"very-hard\":    34\n                \"insane\":       25\n                \"inhuman\":      17\n\n\n        You may also enter a custom number of squares to be given, e.g.,\n\n            // Generate a new Sudoku puzzle with 60 given squares\n            sudoku.generate(60)\n\n\n        `difficulty` must be a number between 17 and 81 inclusive. If it's\n        outside of that range, `difficulty` will be set to the closest bound,\n        e.g., 0 -> 17, and 100 -> 81.\n\n\n        By default, the puzzles are unique, uless you set `unique` to false.\n        (Note: Puzzle uniqueness is not yet implemented, so puzzles are *not*\n        guaranteed to have unique solutions)\n\n        TODO: Implement puzzle uniqueness\n        */\n\n        // If `difficulty` is a string or undefined, convert it to a number or\n        // default it to \"easy\" if undefined.\n        if(typeof difficulty === \"string\" || typeof difficulty === \"undefined\"){\n            difficulty = DIFFICULTY[difficulty] || DIFFICULTY.easy;\n        }\n\n        // Force difficulty between 17 and 81 inclusive\n        difficulty = sudoku._force_range(difficulty, NR_SQUARES + 1,\n                MIN_GIVENS);\n\n        // Default unique to true\n        unique = unique || true;\n\n        // Get a set of squares and all possible candidates for each square\n        var blank_board = \"\";\n        for(var i = 0; i < NR_SQUARES; ++i){\n            blank_board += '.';\n        }\n        var candidates = sudoku._get_candidates_map(blank_board);\n\n        // For each item in a shuffled list of squares\n        var shuffled_squares = sudoku._shuffle(SQUARES);\n        for(var si in shuffled_squares){\n            var square = shuffled_squares[si];\n\n            // If an assignment of a random chioce causes a contradictoin, give\n            // up and try again\n            var rand_candidate_idx =\n                    sudoku._rand_range(candidates[square].length);\n            var rand_candidate = candidates[square][rand_candidate_idx];\n            if(!sudoku._assign(candidates, square, rand_candidate)){\n                break;\n            }\n\n            // Make a list of all single candidates\n            var single_candidates = [];\n            for(si in SQUARES){\n                square = SQUARES[si];\n\n                if(candidates[square].length === 1){\n                    single_candidates.push(candidates[square]);\n                }\n            }\n\n            // If we have at least difficulty, and the unique candidate count is\n            // at least 8, return the puzzle!\n            if(single_candidates.length >= difficulty &&\n                    sudoku._strip_dups(single_candidates).length >= 8){\n                var board = \"\";\n                var givens_idxs = [];\n                for(i in SQUARES){\n                    square = SQUARES[i];\n                    if(candidates[square].length === 1){\n                        board += candidates[square];\n                        givens_idxs.push(i);\n                    } else {\n                        board += sudoku.BLANK_CHAR;\n                    }\n                }\n\n                // If we have more than `difficulty` givens, remove some random\n                // givens until we're down to exactly `difficulty`\n                var nr_givens = givens_idxs.length;\n                if(nr_givens > difficulty){\n                    givens_idxs = sudoku._shuffle(givens_idxs);\n                    for(i = 0; i < nr_givens - difficulty; ++i){\n                        var target = parseInt(givens_idxs[i]);\n                        board = board.substr(0, target) + sudoku.BLANK_CHAR +\n                            board.substr(target + 1);\n                    }\n                }\n\n                // Double check board is solvable\n                // TODO: Make a standalone board checker. Solve is expensive.\n                if(sudoku.solve(board)){\n                    return board;\n                }\n            }\n        }\n\n        // Give up and try a new puzzle\n        return sudoku.generate(difficulty);\n    };\n\n    // Solve\n    // -------------------------------------------------------------------------\n    sudoku.solve = function(board, reverse){\n        /* Solve a sudoku puzzle given a sudoku `board`, i.e., an 81-character\n        string of sudoku.DIGITS, 1-9, and spaces identified by '.', representing the\n        squares. There must be a minimum of 17 givens. If the given board has no\n        solutions, return false.\n\n        Optionally set `reverse` to solve \"backwards\", i.e., rotate through the\n        possibilities in reverse. Useful for checking if there is more than one\n        solution.\n        */\n\n        // Assure a valid board\n        var report = sudoku.validate_board(board);\n        if(report !== true){\n            throw report;\n        }\n\n        // Check number of givens is at least MIN_GIVENS\n        var nr_givens = 0;\n        for(var i in board){\n            if(board[i] !== sudoku.BLANK_CHAR && sudoku._in(board[i], sudoku.DIGITS)){\n                ++nr_givens;\n            }\n        }\n        if(nr_givens < MIN_GIVENS){\n            // eslint-disable-next-line\n            throw \"Too few givens. Minimum givens is \" + MIN_GIVENS;\n        }\n\n        // Default reverse to false\n        reverse = reverse || false;\n\n        var candidates = sudoku._get_candidates_map(board);\n        var result = sudoku._search(candidates, reverse);\n\n        if(result){\n            var solution = \"\";\n            for(var square in result){\n                solution += result[square];\n            }\n            return solution;\n        }\n        return false;\n    };\n\n    sudoku.get_candidates = function(board){\n        /* Return all possible candidatees for each square as a grid of\n        candidates, returnning `false` if a contradiction is encountered.\n\n        Really just a wrapper for sudoku._get_candidates_map for programmer\n        consumption.\n        */\n\n        // Assure a valid board\n        var report = sudoku.validate_board(board);\n        if(report !== true){\n            throw report;\n        }\n\n        // Get a candidates map\n        var candidates_map = sudoku._get_candidates_map(board);\n\n        // If there's an error, return false\n        if(!candidates_map){\n            return false;\n        }\n\n        // Transform candidates map into grid\n        var rows = [];\n        var cur_row = [];\n        var i = 0;\n        for(var square in candidates_map){\n            var candidates = candidates_map[square];\n            cur_row.push(candidates);\n            if(i % 9 === 8){\n                rows.push(cur_row);\n                cur_row = [];\n            }\n            ++i;\n        }\n        return rows;\n    }\n\n    sudoku._get_candidates_map = function(board){\n        /* Get all possible candidates for each square as a map in the form\n        {square: sudoku.DIGITS} using recursive constraint propagation. Return `false`\n        if a contradiction is encountered\n        */\n\n        // Assure a valid board\n        var report = sudoku.validate_board(board);\n        if(report !== true){\n            throw report;\n        }\n\n        var candidate_map = {};\n        var squares_values_map = sudoku._get_square_vals_map(board);\n\n        // Start by assigning every digit as a candidate to every square\n        for(var si in SQUARES){\n            candidate_map[SQUARES[si]] = sudoku.DIGITS;\n        }\n\n        // For each non-blank square, assign its value in the candidate map and\n        // propigate.\n        for(var square in squares_values_map){\n            var val = squares_values_map[square];\n\n            if(sudoku._in(val, sudoku.DIGITS)){\n                var new_candidates = sudoku._assign(candidate_map, square, val);\n\n                // Fail if we can't assign val to square\n                if(!new_candidates){\n                    return false;\n                }\n            }\n        }\n\n        return candidate_map;\n    };\n\n    sudoku._search = function(candidates, reverse){\n        /* Given a map of squares -> candiates, using depth-first search,\n        recursively try all possible values until a solution is found, or false\n        if no solution exists.\n        */\n\n        // Return if error in previous iteration\n        if(!candidates){\n            return false;\n        }\n\n        // Default reverse to false\n        reverse = reverse || false;\n\n        // If only one candidate for every square, we've a solved puzzle!\n        // Return the candidates map.\n        var max_nr_candidates = 0;\n        // eslint-disable-next-line\n        var max_candidates_square = null;\n        for(var si in SQUARES){\n            var square = SQUARES[si];\n\n            var nr_candidates = candidates[square].length;\n\n            if(nr_candidates > max_nr_candidates){\n                max_nr_candidates = nr_candidates;\n                // eslint-disable-next-line no-unused-vars\n                max_candidates_square = square;\n            }\n        }\n        if(max_nr_candidates === 1){\n            return candidates;\n        }\n\n        // Choose the blank square with the fewest possibilities > 1\n        var min_nr_candidates = 10;\n        var min_candidates_square = null;\n        for(si in SQUARES){\n            square = SQUARES[si];\n\n            nr_candidates = candidates[square].length;\n\n            if(nr_candidates < min_nr_candidates && nr_candidates > 1){\n                min_nr_candidates = nr_candidates;\n                min_candidates_square = square;\n            }\n        }\n\n        // Recursively search through each of the candidates of the square\n        // starting with the one with fewest candidates.\n\n        // Rotate through the candidates forwards\n        var min_candidates = candidates[min_candidates_square];\n        if(!reverse){\n            for(var vi in min_candidates){\n                var val = min_candidates[vi];\n\n                // TODO: Implement a non-rediculous deep copy function\n                var candidates_copy = JSON.parse(JSON.stringify(candidates));\n                var candidates_next = sudoku._search(\n                    sudoku._assign(candidates_copy, min_candidates_square, val)\n                );\n\n                if(candidates_next){\n                    return candidates_next;\n                }\n            }\n\n        // Rotate through the candidates backwards\n        } else {\n            for(vi = min_candidates.length - 1; vi >= 0; --vi){\n                val = min_candidates[vi];\n\n                // TODO: Implement a non-rediculous deep copy function\n                candidates_copy = JSON.parse(JSON.stringify(candidates));\n                candidates_next = sudoku._search(\n                    sudoku._assign(candidates_copy, min_candidates_square, val),\n                    reverse\n                );\n\n                if(candidates_next){\n                    return candidates_next;\n                }\n            }\n        }\n\n        // If we get through all combinations of the square with the fewest\n        // candidates without finding an answer, there isn't one. Return false.\n        return false;\n    };\n\n    sudoku._assign = function(candidates, square, val){\n        /* Eliminate all values, *except* for `val`, from `candidates` at\n        `square` (candidates[square]), and propagate. Return the candidates map\n        when finished. If a contradiciton is found, return false.\n\n        WARNING: This will modify the contents of `candidates` directly.\n        */\n\n        // Grab a list of canidates without 'val'\n        var other_vals = candidates[square].replace(val, \"\");\n\n        // Loop through all other values and eliminate them from the candidates\n        // at the current square, and propigate. If at any point we get a\n        // contradiction, return false.\n        for(var ovi in other_vals){\n            var other_val = other_vals[ovi];\n\n            var candidates_next =\n                sudoku._eliminate(candidates, square, other_val);\n\n            if(!candidates_next){\n                //console.log(\"Contradiction found by _eliminate.\");\n                return false;\n            }\n        }\n\n        return candidates;\n    };\n\n    sudoku._eliminate = function(candidates, square, val){\n        /* Eliminate `val` from `candidates` at `square`, (candidates[square]),\n        and propagate when values or places <= 2. Return updated candidates,\n        unless a contradiction is detected, in which case, return false.\n\n        WARNING: This will modify the contents of `candidates` directly.\n        */\n\n        // If `val` has already been eliminated from candidates[square], return\n        // with candidates.\n        if(!sudoku._in(val, candidates[square])){\n            return candidates;\n        }\n\n        // Remove `val` from candidates[square]\n        candidates[square] = candidates[square].replace(val, '');\n\n        // If the square has only candidate left, eliminate that value from its\n        // peers\n        var nr_candidates = candidates[square].length;\n        if(nr_candidates === 1){\n            var target_val = candidates[square];\n\n            for(var pi in SQUARE_PEERS_MAP[square]){\n                var peer = SQUARE_PEERS_MAP[square][pi];\n\n                var candidates_new =\n                        sudoku._eliminate(candidates, peer, target_val);\n\n                if(!candidates_new){\n                    return false;\n                }\n            }\n\n        // Otherwise, if the square has no candidates, we have a contradiction.\n        // Return false.\n        } if(nr_candidates === 0){\n            return false;\n        }\n\n        // If a unit is reduced to only one place for a value, then assign it\n        for(var ui in SQUARE_UNITS_MAP[square]){\n            var unit = SQUARE_UNITS_MAP[square][ui];\n\n            var val_places = [];\n            for(var si in unit){\n                var unit_square = unit[si];\n                if(sudoku._in(val, candidates[unit_square])){\n                    val_places.push(unit_square);\n                }\n            }\n\n            // If there's no place for this value, we have a contradition!\n            // return false\n            if(val_places.length === 0){\n                return false;\n\n            // Otherwise the value can only be in one place. Assign it there.\n            } else if(val_places.length === 1){\n                candidates_new =\n                    sudoku._assign(candidates, val_places[0], val);\n\n                if(!candidates_new){\n                    return false;\n                }\n            }\n        }\n\n        return candidates;\n    };\n\n\n    // Square relationships\n    // -------------------------------------------------------------------------\n    // Squares, and their relationships with values, units, and peers.\n\n    sudoku._get_square_vals_map = function(board){\n        /* Return a map of squares -> values\n        */\n        var squares_vals_map = {};\n\n        // Make sure `board` is a string of length 81\n        if(board.length !== SQUARES.length){\n            // eslint-disable-next-line\n            throw \"Board/squares length mismatch.\";\n\n        } else {\n            for(var i in SQUARES){\n                squares_vals_map[SQUARES[i]] = board[i];\n            }\n        }\n\n        return squares_vals_map;\n    };\n\n    sudoku._get_square_units_map = function(squares, units){\n        /* Return a map of `squares` and their associated units (row, col, box)\n        */\n        var square_unit_map = {};\n\n        // For every square...\n        for(var si in squares){\n            var cur_square = squares[si];\n\n            // Maintain a list of the current square's units\n            var cur_square_units = [];\n\n            // Look through the units, and see if the current square is in it,\n            // and if so, add it to the list of of the square's units.\n            for(var ui in units){\n                var cur_unit = units[ui];\n\n                if(cur_unit.indexOf(cur_square) !== -1){\n                    cur_square_units.push(cur_unit);\n                }\n            }\n\n            // Save the current square and its units to the map\n            square_unit_map[cur_square] = cur_square_units;\n        }\n\n        return square_unit_map;\n    };\n\n    sudoku._get_square_peers_map = function(squares, units_map){\n        /* Return a map of `squares` and their associated peers, i.e., a set of\n        other squares in the square's unit.\n        */\n        var square_peers_map = {};\n\n        // For every square...\n        for(var si in squares){\n            var cur_square = squares[si];\n            var cur_square_units = units_map[cur_square];\n\n            // Maintain list of the current square's peers\n            var cur_square_peers = [];\n\n            // Look through the current square's units map...\n            for(var sui in cur_square_units){\n                var cur_unit = cur_square_units[sui];\n\n                for(var ui in cur_unit){\n                    var cur_unit_square = cur_unit[ui];\n\n                    if(cur_square_peers.indexOf(cur_unit_square) === -1 &&\n                            cur_unit_square !== cur_square){\n                        cur_square_peers.push(cur_unit_square);\n                    }\n                }\n            }\n\n            // Save the current square an its associated peers to the map\n            square_peers_map[cur_square] = cur_square_peers;\n        }\n\n        return square_peers_map;\n    };\n\n    sudoku._get_all_units = function(rows, cols){\n        /* Return a list of all units (rows, cols, boxes)\n        */\n        var units = [];\n\n        // Rows\n        for(var ri in rows){\n            units.push(sudoku._cross(rows[ri], cols));\n        }\n\n        // Columns\n        for(var ci in cols){\n           units.push(sudoku._cross(rows, cols[ci]));\n        }\n\n        // Boxes\n        var row_squares = [\"ABC\", \"DEF\", \"GHI\"];\n        var col_squares = [\"123\", \"456\", \"789\"];\n        for(var rsi in row_squares){\n            for(var csi in col_squares){\n                units.push(sudoku._cross(row_squares[rsi], col_squares[csi]));\n            }\n        }\n\n        return units;\n    };\n\n\n    // Conversions\n    // -------------------------------------------------------------------------\n    sudoku.board_string_to_grid = function(board_string){\n        /* Convert a board string to a two-dimensional array\n        */\n        var rows = [];\n        var cur_row = [];\n        for(var i in board_string){\n            cur_row.push(board_string[i]);\n            if(i % 9 === 8){\n                rows.push(cur_row);\n                cur_row = [];\n            }\n        }\n        return rows;\n    };\n\n    sudoku.board_grid_to_string = function(board_grid){\n        /* Convert a board grid to a string\n        */\n        var board_string = \"\";\n        for(var r = 0; r < 9; ++r){\n            for(var c = 0; c < 9; ++c){\n                board_string += board_grid[r][c];\n            }\n        }\n        return board_string;\n    };\n\n\n    // Utility\n    // -------------------------------------------------------------------------\n\n    sudoku.print_board = function(board){\n        /* Print a sudoku `board` to the console.\n        */\n\n        // Assure a valid board\n        var report = sudoku.validate_board(board);\n        if(report !== true){\n            throw report;\n        }\n\n        var V_PADDING = \" \";  // Insert after each square\n        var H_PADDING = '\\n'; // Insert after each row\n\n        var V_BOX_PADDING = \"  \"; // Box vertical padding\n        var H_BOX_PADDING = '\\n'; // Box horizontal padding\n\n        var display_string = \"\";\n\n        for(var i in board){\n            var square = board[i];\n\n            // Add the square and some padding\n            display_string += square + V_PADDING;\n\n            // Vertical edge of a box, insert v. box padding\n            if(i % 3 === 2){\n                display_string += V_BOX_PADDING;\n            }\n\n            // End of a line, insert horiz. padding\n            if(i % 9 === 8){\n                display_string += H_PADDING;\n            }\n\n            // Horizontal edge of a box, insert h. box padding\n            if(i % 27 === 26){\n                display_string += H_BOX_PADDING;\n            }\n        }\n\n        console.log(display_string);\n    };\n\n    sudoku.validate_board = function(board){\n        /* Return if the given `board` is valid or not. If it's valid, return\n        true. If it's not, return a string of the reason why it's not.\n        */\n\n        // Check for empty board\n        if(!board){\n            return \"Empty board\";\n        }\n\n        // Invalid board length\n        if(board.length !== NR_SQUARES){\n            return \"Invalid board size. Board must be exactly \" + NR_SQUARES +\n                    \" squares.\";\n        }\n\n        // Check for invalid characters\n        for(var i in board){\n            if(!sudoku._in(board[i], sudoku.DIGITS) && board[i] !== sudoku.BLANK_CHAR){\n                return \"Invalid board character encountered at index \" + i +\n                        \": \" + board[i];\n            }\n        }\n\n        // Otherwise, we're good. Return true.\n        return true;\n    };\n\n    sudoku._cross = function(a, b){\n        /* Cross product of all elements in `a` and `b`, e.g.,\n        sudoku._cross(\"abc\", \"123\") ->\n        [\"a1\", \"a2\", \"a3\", \"b1\", \"b2\", \"b3\", \"c1\", \"c2\", \"c3\"]\n        */\n        var result = [];\n        for(var ai in a){\n            for(var bi in b){\n                result.push(a[ai] + b[bi]);\n            }\n        }\n        return result;\n    };\n\n    sudoku._in = function(v, seq){\n        /* Return if a value `v` is in sequence `seq`.\n        */\n        return seq.indexOf(v) !== -1;\n    };\n\n    sudoku._first_true = function(seq){\n        /* Return the first element in `seq` that is true. If no element is\n        true, return false.\n        */\n        for(var i in seq){\n            if(seq[i]){\n                return seq[i];\n            }\n        }\n        return false;\n    };\n\n    sudoku._shuffle = function(seq){\n        /* Return a shuffled version of `seq`\n        */\n\n        // Create an array of the same size as `seq` filled with false\n        var shuffled = [];\n        for(var i = 0; i < seq.length; ++i){\n            shuffled.push(false);\n        }\n\n        for(i in seq){\n            var ti = sudoku._rand_range(seq.length);\n\n            while(shuffled[ti]){\n                ti = (ti + 1) > (seq.length - 1) ? 0 : (ti + 1);\n            }\n\n            shuffled[ti] = seq[i];\n        }\n\n        return shuffled;\n    };\n\n    sudoku._rand_range = function(max, min){\n        /* Get a random integer in the range of `min` to `max` (non inclusive).\n        If `min` not defined, default to 0. If `max` not defined, throw an\n        error.\n        */\n        min = min || 0;\n        if(max){\n            return Math.floor(Math.random() * (max - min)) + min;\n        } else {\n            // eslint-disable-next-line\n            throw \"Range undefined\";\n        }\n    };\n\n    sudoku._strip_dups = function(seq){\n        /* Strip duplicate values from `seq`\n        */\n        var seq_set = [];\n        var dup_map = {};\n        for(var i in seq){\n            var e = seq[i];\n            if(!dup_map[e]){\n                seq_set.push(e);\n                dup_map[e] = true;\n            }\n        }\n        return seq_set;\n    };\n\n    sudoku._force_range = function(nr, max, min){\n        /* Force `nr` to be within the range from `min` to, but not including,\n        `max`. `min` is optional, and will default to 0. If `nr` is undefined,\n        treat it as zero.\n        */\n        min = min || 0\n        nr = nr || 0\n        if(nr < min){\n            return min;\n        }\n        if(nr > max){\n            return max;\n        }\n        return nr\n    }\n\n    // Initialize library after load\n    initialize();\n\n    export const getSudoku = () => {\n      return sudoku;\n    }\n\n// Pass whatever the root object is, like 'window' in browsers\n//})(this);\n","/**\n *  This file gets the solved sudoku from 'sudoku.js' and\n * generates a unique sudoku position from it.\n *\n *  Initially, I tried the sudokus generated by 'sudoku.js'. But\n * it didnt handle the difficulty properly. An 'Easy' sudoku is\n * not that easy, and can be quite hard sometimes! And, filling\n * is uneven. Sometimes, entire rows/columns/boxes are filled!\n *\n *  The 'sudoku.js' code is untouched, except for the minimal\n * changes required to import it here.\n *\n *  The 'sudoku.js' javascript library by robatron is at\n * https://github.com/robatron/sudoku.js . All credits to\n * robatron for taking the hustle out of creating valid sudokus!\n *\n *  My code in this module builds on his code! This wouldn't\n * be possible without people like him sharing in the\n * open source community!\n */\nimport { getSudoku } from './sudoku';\n\n/**\n * The Sudoku position is 9x9.\n *    A1 A2 A3 A4 A5 A6 A7 A8 A9\n *    B1 B2 B3 B4 B5 B6 B7 B8 B9\n *    C1 C2 C3 C4 C5 C6 C7 C8 C9\n *    D1 D2 D3 D4 D5 D6 D7 D8 D9\n *    E1 E2 E3 E4 E5 E6 E7 E8 E9\n *    F1 F2 F3 F4 F5 F6 F7 F8 F9\n *    G1 G2 G3 G4 G5 G6 G7 G8 G9\n *    H1 H2 H3 H4 H5 H6 H7 H8 H9\n *    I1 I2 I3 I4 I5 I6 I7 I8 I9\n *\n * It can be considered to be comprised of 9 boxes\n * each, stacked in a 3x3 formation.\n * Like this: Box1 Box2 Box3\n *            Box4 Box5 Box6\n *            Box7 Box8 Box9\n *\n * In turn, each box is comprised of 9 cells stacked\n * in a 3x3 formation as above. This gives us the below\n * representation:\n *      Box1        Box2        Box3\n *    A1 A2 A3    A4 A5 A6    A7 A8 A9\n *    B1 B2 B3    B4 B5 B6    B7 B8 B9\n *    C1 C2 C3    C4 C5 C6    C7 C8 C9\n *      Box4        Box5        Box6\n *    D1 D2 D3    D4 D5 D6    D7 D8 D9\n *    E1 E2 E3    E4 E5 E6    E7 E8 E9\n *    F1 F2 F3    F4 F5 F6    F7 F8 F9\n *      Box7        Box8        Box9\n *    G1 G2 G3    G4 G5 G6    G7 G8 G9\n *    H1 H2 H3    H4 H5 H6    H7 H8 H9\n *    I1 I2 I3    I4 I5 I6    I7 I8 I9\n *\n * For example, Box1 has the following cells:\n * Box1: A1 A2 A3\n *       B1 B2 B3\n *       C1 C2 C3\n *\n * So in Box1,\n *    Cell1: A1   Cell2: A2   Cell3: A3\n *    Cell4: B1   Cell5: B2   Cell6: B3\n *    Cell7: C1   Cell8: C2   Cell9: C3\n *\n * and in Box8,\n *    Cell1: G4   Cell2: G5   Cell3: G6\n *    Cell4: H4   Cell5: H5   Cell6: H6\n *    Cell7: I4   Cell8: I5   Cell9: I6\n *\n * and so on...\n */\n\n/**\n * Initializes a null array for easier resets in the code.\n */\nlet nullArray = [ '0', '0', '0', '0', '0', '0', '0', '0', '0',\n                  '0', '0', '0', '0', '0', '0', '0', '0', '0',\n                  '0', '0', '0', '0', '0', '0', '0', '0', '0',\n                  '0', '0', '0', '0', '0', '0', '0', '0', '0',\n                  '0', '0', '0', '0', '0', '0', '0', '0', '0',\n                  '0', '0', '0', '0', '0', '0', '0', '0', '0',\n                  '0', '0', '0', '0', '0', '0', '0', '0', '0',\n                  '0', '0', '0', '0', '0', '0', '0', '0', '0',\n                  '0', '0', '0', '0', '0', '0', '0', '0', '0' ];\n\n/**\n * Gets the coordinates of the center cell of the specified box.\n */\nfunction _getBoxCenter(box: number) {\n  // eslint-disable-next-line\n  switch(box) {\n    case 0: return [1,1];\n    case 1: return [1,4];\n    case 2: return [1,7];\n    case 3: return [4,1];\n    case 4: return [4,4];\n    case 5: return [4,7];\n    case 6: return [7,1];\n    case 7: return [7,4];\n    default: return [7,7];\n  }\n}\n\n/**\n * Gets the index of cell given:\n * 1. Box\n * 2. Cell\n */\nfunction _getIndexOfCell(box: number, cell: number) {\n  let [row, column] = _getBoxCenter(box);\n  // eslint-disable-next-line\n  switch(cell) {\n    case 0: {row--; column--; break;}\n    case 1: {row--; break;}\n    case 2: {row--; column++; break;}\n    case 3: {column--; break;}\n    case 4: {break;}\n    case 5: {column++; break;}\n    case 6: {row++; column--; break;}\n    case 7: {row++; break;}\n    case 8: {row++; column++; break;}\n  }\n  return row * 9 + column;\n}\n\n/**\n * Checks if Cell is available or not (i.e., filled).\n */\nfunction _cellAvailable(tempInitArray: string[], box: number, value: number) {\n  return tempInitArray[_getIndexOfCell(box, value)] === '0' ? 0 : 1;\n}\n\n/**\n * Generates a Unique Sudoku puzzle from a solved Sudoku.\n */\nfunction _generateUniqueSudoku(solvedArray: string[], difficulty: string, e?: React.ChangeEvent<HTMLSelectElement>) {\n  let currentDifficulty = difficulty;\n  let minimumCells, maximumCells, totalCells, box, cell;\n\n  let tempInitArray = nullArray.slice();\n  let boxCounts = [ 0,0,0,\n                    0,0,0,\n                    0,0,0 ];\n  let boxesAvailable = [];\n  let cellsAvailable = [];\n\n  if (e)\n    currentDifficulty = e.target.value;\n\n  if (currentDifficulty === 'Easy') {\n    minimumCells = 3;\n    maximumCells = 7;\n    totalCells = 45;\n  }\n  else if (currentDifficulty === 'Medium') {\n    minimumCells = 2;\n    maximumCells = 6;\n    totalCells = 40;\n  }\n  else {\n    minimumCells = 1;\n    maximumCells = 5;\n    totalCells = 30;\n  }\n\n  for (let j = 0; j < 9; j++) {\n    boxCounts[j] =  _cellAvailable(tempInitArray, j, 0) +\n                    _cellAvailable(tempInitArray, j, 1) +\n                    _cellAvailable(tempInitArray, j, 2) +\n                    _cellAvailable(tempInitArray, j, 3) +\n                    _cellAvailable(tempInitArray, j, 4) +\n                    _cellAvailable(tempInitArray, j, 5) +\n                    _cellAvailable(tempInitArray, j, 6) +\n                    _cellAvailable(tempInitArray, j, 7) +\n                    _cellAvailable(tempInitArray, j, 8);\n  }\n\n  for (let i = 0; i < totalCells; i++) {\n    boxesAvailable = [];\n    for (let j = 0; j < 9; j++) {\n      if (boxCounts[j] < minimumCells) {\n        boxesAvailable.push(j);\n      }\n    }\n    if (boxesAvailable) {\n      for (let j = 0; j < 9; j++) {\n        if (boxCounts[j] < maximumCells) {\n          boxesAvailable.push(j);\n        }\n      }\n    }\n    box = boxesAvailable[Math.random() * boxesAvailable.length | 0];\n\n    cellsAvailable = [];\n    for (let j = 0; j < 9; j++) {\n      if ( tempInitArray[_getIndexOfCell(box, j)] === '0') {\n        cellsAvailable.push(j);\n      }\n    }\n    cell = cellsAvailable[Math.random() * cellsAvailable.length | 0];\n\n    let index = _getIndexOfCell(box, cell);\n    tempInitArray[index] = solvedArray[index]\n    boxCounts[box]++;\n  }\n\n  return tempInitArray;\n}\n\nexport const getUniqueSudoku = (difficulty: string, e?: React.ChangeEvent<HTMLSelectElement>) => {\n  let temporaryInitArray = nullArray.slice();\n  let temporarySolvedArray = nullArray.slice();\n  let sudoku = getSudoku();\n\n  /**\n   * Get Sudoku from sudoku.js\n   */\n  let str = sudoku.generate(60);\n\n  [...str].forEach((value, index) => {\n    temporaryInitArray[index] = value === '.'\n                        ? '0'\n                        : value;\n  });\n\n  /**\n   * Get the solution from sudoku.js\n   */\n  str = sudoku.solve(str);\n  [...str].forEach((value, index) => {\n    temporarySolvedArray[index] = value;\n  });\n\n  /**\n   * Pass the generated solution and get a unique Sudoku from it!\n   */\n  temporaryInitArray = _generateUniqueSudoku(temporarySolvedArray, difficulty, e);\n\n  return [temporaryInitArray, temporarySolvedArray];\n}\n","import React, { useState, useEffect } from 'react';\nimport moment from 'moment';\nimport { Header } from './components/layout/Header';\nimport { GameSection } from './components/layout/GameSection';\nimport { StatusSection } from './components/layout/StatusSection';\nimport { Footer } from './components/layout/Footer';\nimport { getUniqueSudoku } from './solver/UniqueSudoku';\nimport { useSudokuContext } from './context/SudokuContext';\n\n/**\n * Game is the main React component.\n */\nexport const Game: React.FC<{}> = () => {\n  /**\n   * All the variables for holding state:\n   * gameArray: Holds the current state of the game.\n   * initArray: Holds the initial state of the game.\n   * solvedArray: Holds the solved position of the game.\n   * difficulty: Difficulty level - 'Easy', 'Medium' or 'Hard'\n   * numberSelected: The Number selected in the Status section.\n   * timeGameStarted: Time the current game was started.\n   * mistakesMode: Is Mistakes allowed or not?\n   * fastMode: Is Fast Mode enabled?\n   * cellSelected: If a game cell is selected by the user, holds the index.\n   * history: history of the current game, for 'Undo' purposes.\n   * overlay: Is the 'Game Solved' overlay enabled?\n   * won: Is the game 'won'?\n   */\n  let { numberSelected, setNumberSelected,\n        gameArray, setGameArray,\n        difficulty, setDifficulty,\n        setTimeGameStarted,\n        fastMode, setFastMode,\n        cellSelected, setCellSelected,\n        initArray, setInitArray,\n        setWon } = useSudokuContext();\n  let [ mistakesMode, setMistakesMode ] = useState<boolean>(false);\n  let [ history, setHistory ] = useState<string[][]>([]);\n  let [ solvedArray, setSolvedArray ] = useState<string[]>([]);\n  let [ overlay, setOverlay ] = useState<boolean>(false);\n\n  /**\n   * Creates a new game and initializes the state variables.\n   */\n  function _createNewGame(e?: React.ChangeEvent<HTMLSelectElement>) {\n    let [ temporaryInitArray, temporarySolvedArray ] = getUniqueSudoku(difficulty, e);\n\n    setInitArray(temporaryInitArray);\n    setGameArray(temporaryInitArray);\n    setSolvedArray(temporarySolvedArray);\n    setNumberSelected('0');\n    setTimeGameStarted(moment());\n    setCellSelected(-1);\n    setHistory([]);\n    setWon(false);\n  }\n\n  /**\n   * Checks if the game is solved.\n   */\n  function _isSolved(index: number, value: string) {\n    if (gameArray.every((cell: string, cellIndex: number) => {\n          if (cellIndex === index)\n            return value === solvedArray[cellIndex];\n          else\n            return cell === solvedArray[cellIndex];\n        })) {\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Fills the cell with the given 'value'\n   * Used to Fill / Erase as required.\n   */\n  function _fillCell(index: number, value: string) {\n    if (initArray[index] === '0') {\n      // Direct copy results in interesting set of problems, investigate more!\n      let tempArray = gameArray.slice();\n      let tempHistory = history.slice();\n\n      // Can't use tempArray here, due to Side effect below!!\n      tempHistory.push(gameArray.slice());\n      setHistory(tempHistory);\n\n      tempArray[index] = value;\n      setGameArray(tempArray);\n\n      if (_isSolved(index, value)) {\n        setOverlay(true);\n        setWon(true);\n      }\n    }\n  }\n\n  /**\n   * A 'user fill' will be passed on to the\n   * _fillCell function above.\n   */\n  function _userFillCell(index: number, value: string) {\n    if (mistakesMode) {\n      if (value === solvedArray[index]) {\n        _fillCell(index, value);\n      }\n      else {\n        // TODO: Flash - Mistakes not allowed in Mistakes Mode\n      }\n    } else {\n      _fillCell(index, value);\n    }\n  }\n\n  /**\n   * On Click of 'New Game' link,\n   * create a new game.\n   */\n  function onClickNewGame() {\n    _createNewGame();\n  }\n\n  /**\n   * On Click of a Game cell.\n   */\n  function onClickCell(indexOfArray: number) {\n    if (fastMode && numberSelected !== '0') {\n      _userFillCell(indexOfArray, numberSelected);\n    }\n    setCellSelected(indexOfArray);\n  }\n\n  /**\n   * On Change Difficulty,\n   * 1. Update 'Difficulty' level\n   * 2. Create New Game\n   */\n  function onChangeDifficulty(e: React.ChangeEvent<HTMLSelectElement>) {\n    setDifficulty(e.target.value);\n    _createNewGame(e);\n  }\n\n  /**\n   * On Click of Number in Status section,\n   * either fill cell or set the number.\n   */\n  function onClickNumber(number: string) {\n    if (fastMode) {\n      setNumberSelected(number)\n    } else if (cellSelected !== -1) {\n      _userFillCell(cellSelected,number);\n    }\n  }\n\n  /**\n   * On Click Undo,\n   * try to Undo the latest change.\n   */\n  function onClickUndo() {\n    if(history.length) {\n      let tempHistory = history.slice();\n      let tempArray = tempHistory.pop();\n      setHistory(tempHistory);\n      if (tempArray !== undefined)\n        setGameArray(tempArray);\n    }\n  }\n\n  /**\n   * On Click Erase,\n   * try to delete the cell.\n   */\n  function onClickErase() {\n    if(cellSelected !== -1 && gameArray[cellSelected] !== '0') {\n      _fillCell(cellSelected, '0');\n    }\n  }\n\n  /**\n   * On Click Hint,\n   * fill the selected cell if its empty or wrong number is filled.\n   */\n  function onClickHint() {\n    if (cellSelected !== -1) {\n      _fillCell(cellSelected, solvedArray[cellSelected]);\n    }\n  }\n\n  /**\n   * Toggle Mistakes Mode\n   */\n  function  onClickMistakesMode() {\n    setMistakesMode(!mistakesMode);\n  }\n\n  /**\n   * Toggle Fast Mode\n   */\n  function onClickFastMode() {\n    if (fastMode) {\n      setNumberSelected('0');\n    }\n    setCellSelected(-1);\n    setFastMode(!fastMode);\n  }\n\n  /**\n   * Close the overlay on Click.\n   */\n  function onClickOverlay() {\n    setOverlay(false);\n    _createNewGame();\n  }\n\n  /**\n   * On load, create a New Game.\n   */\n  useEffect(() => {\n    _createNewGame();\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  return (\n    <>\n      <div className={overlay?\"container blur\":\"container\"}>\n        <Header onClick={onClickNewGame}/>\n        <div className=\"innercontainer\">\n          <GameSection\n            onClick={(indexOfArray: number) => onClickCell(indexOfArray)}\n          />\n          <StatusSection\n            onClickNumber={(number: string) => onClickNumber(number)}\n            onChange={(e: React.ChangeEvent<HTMLSelectElement>) => onChangeDifficulty(e)}\n            onClickUndo={onClickUndo}\n            onClickErase={onClickErase}\n            onClickHint={onClickHint}\n            onClickMistakesMode={onClickMistakesMode}\n            onClickFastMode={onClickFastMode}\n          />\n        </div>\n        <Footer />\n      </div>\n      <div className= { overlay\n                        ? \"overlay overlay--visible\"\n                        : \"overlay\"\n                      }\n           onClick={onClickOverlay}\n      >\n        <h2 className=\"overlay__text\">\n          You <span className=\"overlay__textspan1\">solved</span> <span className=\"overlay__textspan2\">it!</span>\n        </h2>\n      </div>\n    </>\n  );\n}\n","import React from 'react';\nimport { Game } from './Game';\nimport './App.css';\nimport { SudokuProvider } from './context/SudokuContext';\n\n/**\n * App is the root React component.\n */\nexport const App: React.FC<{}> = () => {\n  return (\n    <SudokuProvider>\n      <Game />\n    </SudokuProvider>\n  );\n}\n","import React from 'react';\nimport { render } from 'react-dom';\nimport { App } from './App';\n\nrender(<App />, document.getElementById('root'));\n"],"sourceRoot":""}