diff --git a/src/components/Practice/TypeWord.vue b/src/components/Practice/TypeWord.vue
index 9c77a0ba..5078696e 100644
--- a/src/components/Practice/TypeWord.vue
+++ b/src/components/Practice/TypeWord.vue
@@ -1,19 +1,19 @@
 <script setup lang="ts">
 import {computed, onMounted, onUnmounted, provide, watch} from "vue"
-import 快速打字的机械键盘声音Mp3 from '../assets/sound/key-sounds/快速打字的机械键盘声音.mp3'
-import 键盘快速打字的声音Mp3 from '../assets/sound/key-sounds/键盘快速打字的声音.mp3'
-import 电话打字的声音Mp3 from '../assets/sound/key-sounds/电话打字的声音.mp3'
-import 老式机械 from '../assets/sound/key-sounds/老式机械.mp3'
-import 机械0 from '../assets/sound/key-sounds/jixie/机械0.mp3'
-import 机械1 from '../assets/sound/key-sounds/jixie/机械1.mp3'
-import 机械2 from '../assets/sound/key-sounds/jixie/机械2.mp3'
-import 机械3 from '../assets/sound/key-sounds/jixie/机械3.mp3'
-import beep from '../assets/sound/beep.wav'
-import correct from '../assets/sound/correct.wav'
+import 快速打字的机械键盘声音Mp3 from '../../assets/sound/key-sounds/快速打字的机械键盘声音.mp3'
+import 键盘快速打字的声音Mp3 from '../../assets/sound/key-sounds/键盘快速打字的声音.mp3'
+import 电话打字的声音Mp3 from '../../assets/sound/key-sounds/电话打字的声音.mp3'
+import 老式机械 from '../../assets/sound/key-sounds/老式机械.mp3'
+import 机械0 from '../../assets/sound/key-sounds/jixie/机械0.mp3'
+import 机械1 from '../../assets/sound/key-sounds/jixie/机械1.mp3'
+import 机械2 from '../../assets/sound/key-sounds/jixie/机械2.mp3'
+import 机械3 from '../../assets/sound/key-sounds/jixie/机械3.mp3'
+import beep from '../../assets/sound/beep.wav'
+import correct from '../../assets/sound/correct.wav'
 import {$computed, $ref} from "vue/macros"
 import {useSound} from "@/hooks/useSound.ts"
 import {useBaseStore} from "@/stores/base.ts"
-import {DictType, SaveKey, ShortKeyMap, Statistics, Word} from "../types";
+import {DictType, SaveKey, ShortKeyMap, Statistics, Word} from "../../types";
 import {usePlayWordAudio} from "@/hooks/usePlayWordAudio.ts"
 import useTheme from "@/hooks/useTheme.ts";
 import Tooltip from "@/components/Tooltip.vue";
@@ -24,6 +24,7 @@ import {
 } from "@icon-park/vue-next"
 import {emitter, EventKey} from "@/utils/eventBus.ts"
 import {cloneDeep} from "lodash"
+import {usePracticeStore} from "@/components/Practice/usePracticeStore.ts"
 
 let input = $ref('')
 let wrong = $ref('')
@@ -38,44 +39,10 @@ const [playBeep] = useSound([beep], 1)
 const [playCorrect] = useSound([correct], 1)
 const [playAudio] = usePlayWordAudio()
 
-interface IProps {
-  words: Word[],
-  index: number,
-}
+const practiceStore = usePracticeStore()
 
-const props = withDefaults(defineProps<IProps>(), {
-  words: [],
-  index: -1
-})
-let data = $ref({
-  index: props.index,
-  words: props.words,
-  wrongWords: [],
-  originWrongWords: [],
-  repeatNumber: 0,
-  startDate: Date.now(),
-  correctRate: -1,
-})
-let word = $computed(() => {
-  return data.words[data.index] ?? {
-    trans: [],
-    name: '',
-    usphone: '',
-    ukphone: '',
-  }
-})
 let resetWord = $computed(() => {
-  return word.name.slice(input.length + wrong.length)
-})
-
-watch(data, () => {
-  if (data.index < 1) {
-    return data.correctRate = -1
-  }
-  if (data.wrongWords.length > data.index) {
-    return data.correctRate = 0
-  }
-  data.correctRate = 100 - Math.trunc((data.wrongWords.length / data.index) * 100)
+  return practiceStore.word.name.slice(input.length + wrong.length)
 })
 
 onMounted(() => {
@@ -94,24 +61,24 @@ onUnmounted(() => {
 })
 
 function next() {
-  if (data.index === props.words.length - 1) {
-    if (data.wrongWords.length) {
-      data.words = cloneDeep(data.wrongWords)
-      if (!data.originWrongWords.length) {
-        data.originWrongWords = cloneDeep(data.wrongWords)
+  if (practiceStore.index === practiceStore.words.length - 1) {
+    if (practiceStore.wrongWords.length) {
+      practiceStore.words = cloneDeep(practiceStore.wrongWords)
+      if (!practiceStore.originWrongWords.length) {
+        practiceStore.originWrongWords = cloneDeep(practiceStore.wrongWords)
       }
-      data.index = 0
-      data.repeatNumber++
-      data.wrongWords = []
+      practiceStore.index = 0
+      practiceStore.repeatNumber++
+      practiceStore.wrongWords = []
     } else {
       console.log('这本书完了')
       emitter.emit(EventKey.openStatModal)
     }
   } else {
-    data.index++
+    practiceStore.index++
     console.log('这个词完了')
     if ([DictType.customDict, DictType.innerDict].includes(store.current.dictType)
-        && store.skipWordNames.includes(word.name.toLowerCase())) {
+        && store.skipWordNames.includes(practiceStore.word.name.toLowerCase())) {
       next()
     }
   }
@@ -127,18 +94,18 @@ async function onKeyDown(e: KeyboardEvent) {
   //TODO 还有横杠
   if ((e.keyCode >= 65 && e.keyCode <= 90) || e.code === 'Space') {
     let letter = e.key
-    if ((input + letter).toLowerCase() === word.name.toLowerCase().slice(0, input.length + 1)) {
+    if ((input + letter).toLowerCase() === practiceStore.word.name.toLowerCase().slice(0, input.length + 1)) {
       input += letter
       wrong = ''
       playKeySound()
     } else {
-      if (!store.wrongWordDict.originWords.find((v: Word) => v.name.toLowerCase() === word.name.toLowerCase())) {
-        store.wrongWordDict.originWords.push(word)
-        store.wrongWordDict.words.push(word)
+      if (!store.wrongWordDict.originWords.find((v: Word) => v.name.toLowerCase() === practiceStore.word.name.toLowerCase())) {
+        store.wrongWordDict.originWords.push(practiceStore.word)
+        store.wrongWordDict.words.push(practiceStore.word)
         store.wrongWordDict.chapterWords = [store.wrongWordDict.words]
       }
-      if (!data.wrongWords.find((v: Word) => v.name.toLowerCase() === word.name.toLowerCase())) {
-        data.wrongWords.push(word)
+      if (!practiceStore.wrongWords.find((v: Word) => v.name.toLowerCase() === practiceStore.word.name.toLowerCase())) {
+        practiceStore.wrongWords.push(practiceStore.word)
       }
       wrong = letter
       playKeySound()
@@ -147,7 +114,7 @@ async function onKeyDown(e: KeyboardEvent) {
         wrong = ''
       }, 500)
     }
-    if (input.toLowerCase() === word.name.toLowerCase()) {
+    if (input.toLowerCase() === practiceStore.word.name.toLowerCase()) {
       playCorrect()
       setTimeout(next, 300)
     }
@@ -162,17 +129,17 @@ async function onKeyDown(e: KeyboardEvent) {
         }
         break
       case ShortKeyMap.Collect:
-        if (!store.newWordDict.originWords.find((v: Word) => v.name === word.name)) {
-          store.newWordDict.originWords.push(word)
-          store.newWordDict.words.push(word)
+        if (!store.newWordDict.originWords.find((v: Word) => v.name === practiceStore.word.name)) {
+          store.newWordDict.originWords.push(practiceStore.word)
+          store.newWordDict.words.push(practiceStore.word)
           store.newWordDict.chapterWords = [store.newWordDict.words]
         }
         activeIndex = 1
         break
       case ShortKeyMap.Remove:
-        if (!store.skipWordNames.includes(word.name)) {
-          store.skipWordDict.originWords.push(word)
-          store.skipWordDict.words.push(word)
+        if (!store.skipWordNames.includes(practiceStore.word.name)) {
+          store.skipWordDict.originWords.push(practiceStore.word)
+          store.skipWordDict.words.push(practiceStore.word)
           store.skipWordDict.chapterWords = [store.skipWordDict.words]
         }
         activeIndex = 0
@@ -196,7 +163,7 @@ async function onKeyDown(e: KeyboardEvent) {
 
 <template>
   <div class="type-word">
-    <div class="translate">{{ word.trans.join('；') }}</div>
+    <div class="translate">{{ practiceStore.word.trans.join('；') }}</div>
     <div class="word-wrapper">
       <div class="word" :class="wrong && 'is-wrong'">
         <span class="input" v-if="input">{{ input }}</span>
@@ -208,9 +175,9 @@ async function onKeyDown(e: KeyboardEvent) {
         </template>
         <span class="letter" v-else>{{ resetWord }}</span>
       </div>
-      <div class="audio" @click="playAudio(word.name)">播放</div>
+      <div class="audio" @click="playAudio(practiceStore.word.name)">播放</div>
     </div>
-    <div class="phonetic">{{ word.usphone }}</div>
+    <div class="phonetic">{{ practiceStore.word.usphone }}</div>
     <div class="options">
       <BaseButton keyboard="`" :active="activeIndex === 0">
         忽略
diff --git a/src/components/Practice/TypeWordWrapper.vue b/src/components/Practice/TypeWordWrapper.vue
index 40a1ab0b..6b3ee69e 100644
--- a/src/components/Practice/TypeWordWrapper.vue
+++ b/src/components/Practice/TypeWordWrapper.vue
@@ -1,29 +1,21 @@
 <script setup lang="ts">
 
 import TypeWord from "@/components/TypeWord.vue"
-import {onMounted} from "vue"
+import {onMounted, watch} from "vue"
 import {$ref} from "vue/macros"
-import {watch} from "vue/dist/vue"
 import Footer2 from "@/components/Footer2.vue"
+import {usePracticeStore} from "@/components/Practice/usePracticeStore.ts"
 
-let data = $ref({
-  index: -1,
-  words: [],
-  wrongWords: [],
-  originWrongWords: [],
-  repeatNumber: 0,
-  startDate: Date.now(),
-  correctRate: -1,
-})
+const store = usePracticeStore()
 
-watch(data, () => {
-  if (data.index < 1) {
-    return data.correctRate = -1
+watch(store.$state, () => {
+  if (store.index < 1) {
+    return store.correctRate = -1
   }
-  if (data.wrongWords.length > data.index) {
-    return data.correctRate = 0
+  if (store.wrongWords.length > store.index) {
+    return store.correctRate = 0
   }
-  data.correctRate = 100 - Math.trunc((data.wrongWords.length / data.index) * 100)
+  store.correctRate = 100 - Math.trunc((store.wrongWords.length / store.index) * 100)
 })
 
 onMounted(() => {
diff --git a/src/components/Practice/usePracticeStore.ts b/src/components/Practice/usePracticeStore.ts
index cc985266..cc0851b6 100644
--- a/src/components/Practice/usePracticeStore.ts
+++ b/src/components/Practice/usePracticeStore.ts
@@ -1,5 +1,5 @@
 import {defineStore} from "pinia"
-import {Word} from "@/types.ts"
+import {State, Word} from "@/types.ts"
 
 export interface PracticeState {
     index: number,
@@ -28,5 +28,15 @@ export const usePracticeStore = defineStore('practice', {
             inputNumber: -1,
             wrongNumber: -1,
         }
+    },
+    getters: {
+        word(state: PracticeState): Word {
+            return state.words[state.index] ?? {
+                trans: [],
+                name: '',
+                usphone: '',
+                ukphone: '',
+            }
+        },
     }
 })
\ No newline at end of file
diff --git a/src/stores/base.ts b/src/stores/base.ts
index cfdb44d3..03b67869 100644
--- a/src/stores/base.ts
+++ b/src/stores/base.ts
@@ -4,223 +4,223 @@ import {chunk, cloneDeep} from "lodash";
 import {emitter, EventKey} from "@/utils/eventBus.ts"
 
 export const useBaseStore = defineStore('base', {
-  state: (): State => {
-    return {
-      newWordDict: {
-        name: '生词本',
-        sort: Sort.normal,
-        type: DictType.newDict,
-        originWords: [],
-        words: [],
-        chapterWordNumber: 15,
-        chapterWords: [],
-        chapterIndex: 0,
-        chapterWordIndex: 0,
-        statistics: [],
-        url: '',
-      },
-      skipWordDict: {
-        name: '简单词',
-        sort: Sort.normal,
-        type: DictType.skipDict,
-        originWords: [],
-        words: [],
-        chapterWordNumber: 15,
-        chapterWords: [],
-        chapterIndex: 0,
-        chapterWordIndex: 0,
-        statistics: [],
-        url: '',
-      },
-      wrongWordDict: {
-        name: '错词本',
-        sort: Sort.normal,
-        type: DictType.wrongDict,
-        originWords: [],
-        words: [],
-        chapterWordNumber: 15,
-        chapterWords: [],
-        chapterIndex: 0,
-        chapterWordIndex: 0,
-        statistics: [],
-        url: '',
-      },
-      dict: {
-        name: '新概念英语-2',
-        sort: Sort.normal,
-        type: DictType.innerDict,
-        originWords: [],
-        words: [],
-        chapterWordNumber: 15,
-        chapterWords: [],
-        chapterIndex: 0,
-        chapterWordIndex: 0,
-        statistics: [],
-        url: '/dicts/NCE_2.json',
-      },
-      oldDicts: [],
-      current: {
-        dictType: DictType.innerDict,
-        words: [],
-        index: -1,
-        wrongWords: [],
-        originWrongWords: [],
-        repeatNumber: 0,
-        statistics: {
-          startDate: -1,
-          endDate: -1,
-          spend: -1,
-          wordNumber: -1,
-          correctRate: -1,
-          wrongWordNumber: -1,
+    state: (): State => {
+        return {
+            newWordDict: {
+                name: '生词本',
+                sort: Sort.normal,
+                type: DictType.newDict,
+                originWords: [],
+                words: [],
+                chapterWordNumber: 15,
+                chapterWords: [],
+                chapterIndex: 0,
+                chapterWordIndex: 0,
+                statistics: [],
+                url: '',
+            },
+            skipWordDict: {
+                name: '简单词',
+                sort: Sort.normal,
+                type: DictType.skipDict,
+                originWords: [],
+                words: [],
+                chapterWordNumber: 15,
+                chapterWords: [],
+                chapterIndex: 0,
+                chapterWordIndex: 0,
+                statistics: [],
+                url: '',
+            },
+            wrongWordDict: {
+                name: '错词本',
+                sort: Sort.normal,
+                type: DictType.wrongDict,
+                originWords: [],
+                words: [],
+                chapterWordNumber: 15,
+                chapterWords: [],
+                chapterIndex: 0,
+                chapterWordIndex: 0,
+                statistics: [],
+                url: '',
+            },
+            dict: {
+                name: '新概念英语-2',
+                sort: Sort.normal,
+                type: DictType.innerDict,
+                originWords: [],
+                words: [],
+                chapterWordNumber: 15,
+                chapterWords: [],
+                chapterIndex: 0,
+                chapterWordIndex: 0,
+                statistics: [],
+                url: '/dicts/NCE_2.json',
+            },
+            oldDicts: [],
+            current: {
+                dictType: DictType.innerDict,
+                words: [],
+                index: -1,
+                wrongWords: [],
+                originWrongWords: [],
+                repeatNumber: 0,
+                statistics: {
+                    startDate: -1,
+                    endDate: -1,
+                    spend: -1,
+                    wordNumber: -1,
+                    correctRate: -1,
+                    wrongWordNumber: -1,
+                }
+            },
+            sideIsOpen: false,
+            isDictation: true,
+            setting: {
+                showToolbar: true,
+                show: false,
+                value1: false,
+                value2: 50,
+                value3: 1,
+                value4: false,
+            },
+            simpleWords: [
+                'a', 'an', 'of', 'and',
+                'i', 'my', 'you', 'your',
+                'me', 'am', 'is', 'do', 'are',
+                'what', 'who', 'where', 'how', 'no', 'yes',
+                'not', 'did', 'were', 'can', 'could', 'it',
+                'the', 'to'
+            ],
+            theme: 'auto'
         }
-      },
-      sideIsOpen: false,
-      isDictation: true,
-      setting: {
-        showToolbar: true,
-        show: false,
-        value1: false,
-        value2: 50,
-        value3: 1,
-        value4: false,
-      },
-      simpleWords: [
-        'a', 'an', 'of', 'and',
-        'i', 'my', 'you', 'your',
-        'me', 'am', 'is', 'do', 'are',
-        'what', 'who', 'where', 'how', 'no', 'yes',
-        'not', 'did', 'were', 'can', 'could', 'it',
-        'the','to'
-      ],
-      theme: 'auto'
-    }
-  },
-  getters: {
-    skipWordNames: (state: State) => {
-      return state.skipWordDict.originWords.map(v => v.name.toLowerCase())
     },
-    skipWordNamesWithSimpleWords: (state: State) => {
-      return state.skipWordDict.originWords.map(v => v.name.toLowerCase()).concat(state.simpleWords)
-    },
-    currentDict(state: State): Dict {
-      switch (state.current.dictType) {
-        case DictType.newDict:
-          return state.newWordDict
-        case DictType.skipDict:
-          return state.skipWordDict
-        case DictType.wrongDict:
-          return state.wrongWordDict
-        case DictType.innerDict:
-        case DictType.customDict:
-          return state.dict
-      }
-    },
-    wordIndex(state: State): number {
-      return this.currentDict.wordIndex
-    },
-    chapter(state: State): Word[] {
-      return this.currentDict.chapterWords[this.currentDict.chapterIndex] ?? []
-    },
-    word(state: State): Word {
-      return state.current.words[state.current.index] ?? {
-        trans: [],
-        name: '',
-        usphone: '',
-        ukphone: '',
-      }
-    },
-    dictTitle(state: State) {
-      let title = this.currentDict.name
-      if ([DictType.innerDict, DictType.customDict].includes(this.current.dictType)) {
-        title += `  第${this.currentDict.chapterIndex + 1}章`
-        title += this.current.repeatNumber ? '  复习错词' : ''
-      }
-      return title
-    }
-  },
-  actions: {
-    setState(obj: any) {
-      for (const [key, value] of Object.entries(obj)) {
-        this[key] = value
-      }
-      // console.log('this/', this)
-    },
-    setCurrentWord(words: Word[], restart: boolean = false, index: number = 0) {
-      this.current.words = cloneDeep(words)
-      if (restart) {
-        this.current.repeatNumber = 0
-        this.current.originWrongWords = []
-        this.current.statistics = {
-          startDate: Date.now(),
-          endDate: -1,
-          spend: -1,
-          wordNumber: words.length,
-          correctRate: -1,
-          wrongWordNumber: -1,
+    getters: {
+        skipWordNames: (state: State) => {
+            return state.skipWordDict.originWords.map(v => v.name.toLowerCase())
+        },
+        skipWordNamesWithSimpleWords: (state: State) => {
+            return state.skipWordDict.originWords.map(v => v.name.toLowerCase()).concat(state.simpleWords)
+        },
+        currentDict(state: State): Dict {
+            switch (state.current.dictType) {
+                case DictType.newDict:
+                    return state.newWordDict
+                case DictType.skipDict:
+                    return state.skipWordDict
+                case DictType.wrongDict:
+                    return state.wrongWordDict
+                case DictType.innerDict:
+                case DictType.customDict:
+                    return state.dict
+            }
+        },
+        wordIndex(state: State): number {
+            return this.currentDict.wordIndex
+        },
+        chapter(state: State): Word[] {
+            return this.currentDict.chapterWords[this.currentDict.chapterIndex] ?? []
+        },
+        word(state: State): Word {
+            return state.current.words[state.current.index] ?? {
+                trans: [],
+                name: '',
+                usphone: '',
+                ukphone: '',
+            }
+        },
+        dictTitle(state: State) {
+            let title = this.currentDict.name
+            if ([DictType.innerDict, DictType.customDict].includes(this.current.dictType)) {
+                title += `  第${this.currentDict.chapterIndex + 1}章`
+                title += this.current.repeatNumber ? '  复习错词' : ''
+            }
+            return title
         }
-      } else {
-        this.current.repeatNumber++
-        if (!this.current.originWrongWords.length) {
-          this.current.originWrongWords = cloneDeep(this.current.wrongWords)
+    },
+    actions: {
+        setState(obj: any) {
+            for (const [key, value] of Object.entries(obj)) {
+                this[key] = value
+            }
+            // console.log('this/', this)
+        },
+        setCurrentWord(words: Word[], restart: boolean = false, index: number = 0) {
+            this.current.words = cloneDeep(words)
+            if (restart) {
+                this.current.repeatNumber = 0
+                this.current.originWrongWords = []
+                this.current.statistics = {
+                    startDate: Date.now(),
+                    endDate: -1,
+                    spend: -1,
+                    wordNumber: words.length,
+                    correctRate: -1,
+                    wrongWordNumber: -1,
+                }
+            } else {
+                this.current.repeatNumber++
+                if (!this.current.originWrongWords.length) {
+                    this.current.originWrongWords = cloneDeep(this.current.wrongWords)
+                }
+                this.current.statistics.correctRate = -1
+                this.current.statistics.wrongWordNumber = -1
+            }
+            this.current.index = index
+            this.current.wrongWords = []
+        },
+        async init() {
+            // let configStr = localStorage.getItem(SaveKey)
+            // if (configStr) {
+            //   let obj: Config = JSON.parse(configStr)
+            //   this.setState(obj)
+            // }
+            if (this.current.dictType === DictType.innerDict) {
+                let r = await fetch(`/public/${this.dict.url}`)
+                r.json().then(v => {
+                    this.dict.originWords = cloneDeep(v)
+                    this.dict.words = cloneDeep(v)
+                    this.dict.chapters = chunk(this.dict.words, this.dict.chapterWordNumber)
+                    this.setCurrentWord(this.chapter, true)
+                })
+            }
+        },
+        saveStatistics() {
+            let currentStat = cloneDeep(this.current.statistics)
+            currentStat.endDate = Date.now()
+            currentStat.spend = Date.now() - currentStat.startDate
+            currentStat.wrongWordNumber = this.current.originWrongWords.length
+            currentStat.correctRate = 100 - Math.trunc((currentStat.wrongWordNumber / currentStat.wordNumber) * 100)
+            // console.log(cloneDeep(currentStat))
+            if (currentStat.spend > 1000 * 10) {
+                this.currentDict.statistics.push(currentStat)
+            }
+            return currentStat
+        },
+        async changeDict(dict: Dict, chapterIndex: number = dict.chapterIndex, chapterWordIndex: number = dict.chapterWordNumber) {
+            this.saveStatistics()
+            console.log('changeDict', cloneDeep(dict), chapterIndex, chapterWordIndex)
+            this.current.dictType = dict.type
+            if ([DictType.newDict,
+                DictType.skipDict,
+                DictType.wrongDict].includes(dict.type)) {
+                this[dict.type].chapterIndex = chapterIndex
+                this[dict.type].chapterWordIndex = chapterWordIndex
+            } else {
+                this.dict = cloneDeep(dict)
+                if (dict.originWords.length) {
+                    let r = await fetch(`/public/${this.dict.url}`)
+                    let v = await r.json()
+                    this.dict.originWords = cloneDeep(v)
+                    this.dict.words = cloneDeep(v)
+                    this.dict.chapters = chunk(this.dict.words, this.dict.chapterWordNumber)
+                }
+                this.dict.chapterIndex = chapterIndex
+                this.dict.chapterWordIndex = chapterWordIndex
+            }
+            this.setCurrentWord(this.chapter, true, chapterWordIndex)
+            emitter.emit(EventKey.resetWord)
         }
-        this.current.statistics.correctRate = -1
-        this.current.statistics.wrongWordNumber = -1
-      }
-      this.current.index = index
-      this.current.wrongWords = []
     },
-    async init() {
-      // let configStr = localStorage.getItem(SaveKey)
-      // if (configStr) {
-      //   let obj: Config = JSON.parse(configStr)
-      //   this.setState(obj)
-      // }
-      if (this.current.dictType === DictType.innerDict) {
-        let r = await fetch(`/public/${this.dict.url}`)
-        r.json().then(v => {
-          this.dict.originWords = cloneDeep(v)
-          this.dict.words = cloneDeep(v)
-          this.dict.chapters = chunk(this.dict.words, this.dict.chapterWordNumber)
-          this.setCurrentWord(this.chapter, true)
-        })
-      }
-    },
-    saveStatistics() {
-      let currentStat = cloneDeep(this.current.statistics)
-      currentStat.endDate = Date.now()
-      currentStat.spend = Date.now() - currentStat.startDate
-      currentStat.wrongWordNumber = this.current.originWrongWords.length
-      currentStat.correctRate = 100 - Math.trunc((currentStat.wrongWordNumber / currentStat.wordNumber) * 100)
-      // console.log(cloneDeep(currentStat))
-      if (currentStat.spend > 1000 * 10) {
-        this.currentDict.statistics.push(currentStat)
-      }
-      return currentStat
-    },
-    async changeDict(dict: Dict, chapterIndex: number = dict.chapterIndex, chapterWordIndex: number = dict.chapterWordNumber) {
-      this.saveStatistics()
-      console.log('changeDict', cloneDeep(dict), chapterIndex, chapterWordIndex)
-      this.current.dictType = dict.type
-      if ([DictType.newDict,
-        DictType.skipDict,
-        DictType.wrongDict].includes(dict.type)) {
-        this[dict.type].chapterIndex = chapterIndex
-        this[dict.type].chapterWordIndex = chapterWordIndex
-      } else {
-        this.dict = cloneDeep(dict)
-        if (dict.originWords.length) {
-          let r = await fetch(`/public/${this.dict.url}`)
-          let v = await r.json()
-          this.dict.originWords = cloneDeep(v)
-          this.dict.words = cloneDeep(v)
-          this.dict.chapters = chunk(this.dict.words, this.dict.chapterWordNumber)
-        }
-        this.dict.chapterIndex = chapterIndex
-        this.dict.chapterWordIndex = chapterWordIndex
-      }
-      this.setCurrentWord(this.chapter, true, chapterWordIndex)
-      emitter.emit(EventKey.resetWord)
-    }
-  },
 })
\ No newline at end of file