<repo_name>kaolaqi/alittleQQ<file_sep>/src/server/dataStore/index.js

var DataStoreServer = function() {
}

// 设置长期数据
DataStoreServer.prototype.setLongData = function(key, value) {
  window.localStorage.setItem(key, JSON.stringify(value))
}

// 读取长期数据
DataStoreServer.prototype.getLongData = function(key) {
  return JSON.parse(window.localStorage.getItem(key))
}

// 清除长期数据
DataStoreServer.prototype.removeLongData = function(key, clearAll) {
  if (!key && clearAll) {
    window.localStorage.clear()
    return false
  }
  window.localStorage.removeItem(key)
}

// 设置会话数据
DataStoreServer.prototype.set = function(key, value) {
  window.sessionStorage.setItem(key, JSON.stringify(value))
}

// 读取会话数据
DataStoreServer.prototype.get = function(key) {
  return JSON.parse(window.sessionStorage.getItem(key))
}

// 清除会话数据
DataStoreServer.prototype.remove = function(key, clearAll) {
  if (!key && clearAll) {
    window.sessionStorage.clear()
    return false
  }
  window.sessionStorage.removeItem(key)
}

export default new DataStoreServer()

<file_sep>/src/filters/aes.js
var dsbCode = require('crypto-js')

var key = dsbCode.enc.Utf8.parse('BE56E057F20F883E')
var iv = dsbCode.enc.Utf8.parse('E10ADC3949BA59AB')

// var str = dsbCode.MD5('um81msQiWfOiiqGC').toString();
// //新的
// var key = dsbCode.enc.Utf8.parse(str.substring(16).toUpperCase());
// var iv = dsbCode.enc.Utf8.parse(str.substring(0,16).toUpperCase());

/* 加密*/
function encrypt(word) {
  // console.log(word)
  var text = dsbCode.enc.Utf8.parse(word) // 转128bit
  var encrypted = dsbCode.AES.encrypt(text, key, {
    iv: iv,
    mode: dsbCode.mode.CBC,
    padding: dsbCode.pad.Pkcs7
  })
  var encryptedStr = encrypted.ciphertext.toString()
  var encryptedHexStr = dsbCode.enc.Hex.parse(encryptedStr)
  var encryptedBase64Str = dsbCode.enc.Base64.stringify(encryptedHexStr)
  return encryptedBase64Str
}

function iGetInnerText(testStr) {
  var resultStr = testStr.replace(/\ +/g, '') // 去掉空格
  resultStr = testStr.replace(/[ ]/g, '') // 去掉空格
  resultStr = testStr.replace(/[\r\n]/g, '') // 去掉回车换行
  return resultStr
}

/* 解密*/
function decrypt(word) {
  word = iGetInnerText(word)
  // console.log(word)
  var decrypted = dsbCode.AES.decrypt(word, key, {
    iv: iv,
    mode: dsbCode.mode.CBC,
    padding: dsbCode.pad.Pkcs7
  })

  return dsbCode.enc.Utf8.stringify(decrypted).toString()
}

export { encrypt, decrypt }

<file_sep>/src/filters/status.js

import provinceData from '../lib/provinceCode.js'

// 上游消费明细
function consumeTypeFilter(status) {
  switch (+status) {
    case 11:
      return '任务创建扣款'
    case 12:
      return '任务失败加款'
    default:
      return '未知状态'
  }
}

// 根据提现状态返回文本
function withdrawStatus(status) {
  switch (status) {
    case 87:
      return '审核中'
    case 88:
      return '已到账'
    case 89:
      return '未到账'
    default:
      return '未知状态'
  }
}

// 根据订单状态返回文本
function orderStatus(status) {
  switch (status) {
    case 81:
      return '审核中'
    case 82:
      return '审核中'
    case 83:
      return '已成功'
    case 84:
      return '已失败'
    case 85:
      return '已放弃'
    default:
      return '未知状态'
  }
}

// 微信扫码任务类型
function wechatScanMissionType(type) {
  switch (type) {
    case 80:
      return '微信辅助'
    default:
      return '未知状态'
  }
}

// 任务类型
function orderTypeFilter(type) {
  switch (type) {
    case 1:
      return '微信扫码辅助'
    case 2:
      return '微信解封辅助'
    default:
      return '未知状态'
  }
}

// 保证金状态
function ensureMoneyFilter(type) {
  switch (type) {
    case 41:
      return '充值'
    case 42:
      return '违规扣款'
    case 43:
      return '退还'
    case 44:
      return '申诉退款'
    default:
      return '未知状态'
  }
}

// 提现状态
function withdrawFilter(status) {
  switch (status) {
    case 87:
      return '待审核'
    case 88:
      return '转账成功'
    case 89:
      return '转账失败'
    case 90:
      return '审核不通过'
    default:
      return '未知状态'
  }
}

// 过滤省名
function provinceFilter(code) {
  var province = provinceData[code]
  if (!province) {
    return '未知地区'
  }
  return province.province
}

// 提现状态
function walletChangeType(status) {
  switch (status) {
    case 21:
      return '赏金加款'
    case 22:
      return '抽成加款'
    case 26:
      return '提现扣款'
    case 27:
      return '提现退款'
    case 49:
      return '下游邀请金额转入个人余额'
    default:
      return '未知状态'
  }
}

// 申诉状态
function appealStatus(status) {
  switch (status) {
    case 1:
      return '待审核'
    case 2:
      return '申诉成功'
    case 3:
      return '申诉失败'
    default:
      return '未知状态'
  }
}

export {
  consumeTypeFilter,
  withdrawStatus,
  orderStatus,
  wechatScanMissionType,
  orderTypeFilter,
  provinceFilter,
  ensureMoneyFilter,
  withdrawFilter,
  walletChangeType,
  appealStatus
}

<file_sep>/src/server/token/index.js

import Cookies from 'js-cookie'
const TokenKey = 'Admin-Token'

var TokenServer = function() {
  this.getToken = function() {
    return Cookies.get(TokenKey)
  }
  this.setToken = function(token) {
    return Cookies.set(TokenKey, token)
  }
  this.removeToken = function() {
    return Cookies.remove(TokenKey)
  }
}

export default new TokenServer()
<file_sep>/src/server/modals/loading/index.js
/* eslint-disable */
import Vue from 'vue'
import loadingComponent from './main.vue'

// 组件初始化的实例
var loadingInstance = false

// 组件添加初始化挂载方法
loadingComponent.installMessage = function() {
  if (loadingInstance) {
    return loadingInstance
  }
  var loading = Vue.extend(loadingComponent)
  var component = new loading({}).$mount()
  document.querySelector('body').appendChild(component.$el)

  loadingInstance = component
  // 把实例返回出来
  return loadingInstance
}

/** ***********   组件服务   ****************/

// 将组件实例赋给服务 使用函数调用组件方法
var LoadingServer = function() {
  this.instance = loadingComponent.installMessage()
}

// 组件服务方法加载
LoadingServer.prototype.loading = function(message) {
  if (!this.instance) {
    this.instance = loadingComponent.installMessage()
  }
  this.instance.loading(message)
}
// 组件服务卸载
LoadingServer.prototype.unload = function() {
  if (!this.instance) {
    this.instance = loadingComponent.installMessage()
  }
  this.instance.unload()
}

var modalLoadingServer = new LoadingServer()

export default modalLoadingServer

<file_sep>/src/main.js
import Vue from 'vue'
import App from './App'
import store from './store'
import router from './router'
import Vant from 'vant'
import 'vant/lib/index.css'

// 控制台调试工具
// var VConsole = require('vconsole');
// var vConsole = new VConsole();
// require('eruda').init();

import './permission' // permission control
import { clipboard } from '@/directive/index'

// 引入自定义组件
Vue.directive('clipboard', clipboard)
Vue.use(Vant)

Vue.config.productionTip = false

router.beforeEach((to, from, next) => {
  document.title = to.meta.title
  next()
})

new Vue({
  el: '#app',
  router,
  store,
  components: { App },
  template: '<App/>'
})
<file_sep>/src/constants/index.js
// 定义全局变量，配置请求服务器地址
var socketUrl = '' // websocket服务地址

if (process.env.NODE_ENV === 'production') {
  // 正式环境
  socketUrl = 'ws://172.16.58.3:8040'
} else {
  // 测试环境地址
  socketUrl = 'ws://localhost:8050'
}

export {
  socketUrl
}
<file_sep>/src/server/modals/alert/index.js
/* eslint-disable */
import Vue from 'vue'
import alertComponent from './main.vue'

// 组件初始化的实例
var alertInstance = false

// 组件添加初始化挂载方法
alertComponent.installMessage = function() {
  if (alertInstance) {
    return alertInstance
  }
  var loading = Vue.extend(alertComponent)
  var component = new loading({}).$mount()
  document.querySelector('body').appendChild(component.$el)

  alertInstance = component
  // 把实例返回出来
  return alertInstance
}

/** ***********   组件服务   ****************/

// 将组件实例赋给服务 使用函数调用组件方法
var alertServer = function() {
  this.instance = alertComponent.installMessage()
}

// 使用组件服务
//  config.title='标题'
//  config.message = '内容'  *必传*
//  config.confirm = '按钮文本'
//  config.onClickConfirm = '点击确认回调' 默认关闭
alertServer.prototype.use = function(config) {
  if (!this.instance) {
    this.instance = alertComponent.installMessage()
  }
  this.instance.use(config)
}

// 取消
alertServer.prototype.hide = function() {
  if (!this.instance) {
    this.instance = alertComponent.installMessage()
  }
  this.instance.hide()
}

var modalAlertServer = new alertServer()

export default modalAlertServer

<file_sep>/build/build.js
require('./check-versions')()

process.env.NODE_ENV = 'production'

var ora = require('ora')
var rm = require('rimraf')
var path = require('path')
var chalk = require('chalk')
var webpack = require('webpack')
var config = require('../config')
var webpackConfig = require('./webpack.prod.conf')
var webpackTestConfig = require('./webpack.test.conf')



//打包测试环境
function pacelTest (){
    process.env.NODE_ENV = 'test'
    var spinner = ora('开始打包测试环境')
    spinner.start()
    rm(path.join(config.buildTest.assetsRoot, config.buildTest.assetsSubDirectory), err => {
      if (err) throw err
      webpack(webpackTestConfig, function (err, stats) {
        spinner.stop()
        if (err) throw err
        process.stdout.write(stats.toString({
          colors: true,
          modules: false,
          children: false,
          chunks: false,
          chunkModules: false
        }) + '\n\n')
        console.log(chalk.cyan('  Build-test complete  测试环境打包成功.\n'))
        
      })
    })
}



var spinner = ora('开始打包正式环境')
    spinner.start()
rm(path.join(config.build.assetsRoot, config.build.assetsSubDirectory), err => {
  if (err) throw err
  webpack(webpackConfig, function (err, stats) {
    spinner.stop()
    if (err) throw err
    process.stdout.write(stats.toString({
      colors: true,
      modules: false,
      children: false,
      chunks: false,
      chunkModules: false
    }) + '\n\n')
    console.log(chalk.cyan('  Build complete.\n'))
    console.log(chalk.yellow(
      '  Tip: built files are meant to be served over an HTTP server.\n' +
      '  Opening index.html over file:// won\'t work.\n'
    ))
    //开始打包测试环境
    pacelTest();
  })
})



<file_sep>/src/server/http/index.js

import axios from 'axios'
import { modalMessageServer, modalAlertServer } from '../modals/index'
import router from '@/router'
// import store from '@/store'
// import { getToken } from '@/utils/auth'

// create an axios instance
const service = axios.create({
  baseURL: '/',
  timeout: 5000 // request timeout
})

// request interceptor
service.interceptors.request.use(
  config => {
    // do something before request is sent

    // if (store.getters.token) {
    //   // let each request carry token
    //   // ['X-Token'] is a custom headers key
    //   // please modify it according to the actual situation
    //   config.headers['X-Token'] = getToken()
    // }
    return config
  },
  error => {
    // do something with request error
    console.log(error) // for debug
    return Promise.reject(error)
  }
)

// response interceptor
service.interceptors.response.use(
  response => {
    const res = response.data
    if (res.statusCode === 401) {
      modalAlertServer.use({
        content: '登录失效，请重新登录！',
        onClickConfirm: function() {
          // window.location.hash = '/login';
          router.push({ name: 'login' })
          modalAlertServer.hide()
        }
      })
    }
    if (res.statusCode !== 200) {
      modalMessageServer.show(res.message || 'Error', 2000)
      return Promise.reject(new Error(res.message || 'Error'))
    } else {
      return res
    }
  },
  error => {
    console.log('err' + error) // for debug
    modalMessageServer.show(error.message, 2000)
    return Promise.reject(error)
  }
)

export default service
<file_sep>/src/filters/common.js

// 时间输出格式
function dateFormat(date, format) {
  if (!format || typeof format !== 'string') {
    console.log('format is undefiend or type is Error')
  }
  // console.log(date,format)
  date = date instanceof Date ? date : (typeof date === 'number' || typeof date === 'string') ? new Date(date) : new Date()

  var formatReg = {
    'y+': date.getFullYear(),
    'M+': date.getMonth() + 1,
    'd+': date.getDate(),
    'h+': date.getHours(),
    'm+': date.getMinutes(),
    's+': date.getSeconds()
  }
  for (var reg in formatReg) {
    if (new RegExp(reg).test(format)) {
      var match = RegExp.lastMatch
      format = format.replace(match, formatReg[reg] < 10 ? '0' + formatReg[reg] : formatReg[reg].toString().slice(-match.length))
    }
  }
  return format
}

// 计算相差时分秒
function dateCountDown(countDownTime) {
  if (!countDownTime || typeof countDownTime !== 'number') {
    console.log('countDownTime is undefiend or type is Error')
    return false
  }
  var date3 = countDownTime // 时间差的毫秒数

  // ------------------------------
  // 计算出小时数
  var hours = Math.floor(date3 / (3600 * 1000))
  // 计算相差分钟数
  var leave1 = date3 % (24 * 3600 * 1000) // 计算天数后剩余的毫秒数
  var leave2 = leave1 % (3600 * 1000) // 计算小时数后剩余的毫秒数
  var minutes = Math.floor(leave2 / (60 * 1000))
  // 计算相差秒数
  var leave3 = leave2 % (60 * 1000) // 计算分钟数后剩余的毫秒数
  var seconds = Math.round(leave3 / 1000)

  return (hours < 10 ? '0' + hours : hours) + ':' + (minutes < 10 ? '0' + minutes : minutes) + ':' + (seconds < 10 ? '0' + seconds : seconds)
}

export { dateFormat, dateCountDown }

<file_sep>/src/http/user.js
import httpRequestServer from '../server/http/index'

export default {
  // 用户注册
  userResigter(data) {
    return httpRequestServer({
      method: 'POST',
      url: '/api/client/register',
      data: data
    })
  },
  // 登录
  userLogin(data) {
    return httpRequestServer({
      method: 'POST',
      url: '/api/client/login',
      data: data
    })
  },
  // 获取用户信息
  getUserInfo(data) {
    return httpRequestServer({
      method: 'GET',
      url: '/api/client/userInfo',
      params: data
    })
  },
  // 退出登录
  outUser() {
    return httpRequestServer({
      method: 'GET',
      url: '/api/client/logout'
    })
  },

  // 获取用户好友列表
  getUserFriendList(data) {
    return httpRequestServer({
      method: 'GET',
      url: '/api/client/getFriendList',
      params: data
    })
  },

  // 模糊查询系统用户列表
  searchUserList(data) {
    return httpRequestServer({
      method: 'GET',
      url: '/api/client/userList',
      params: data
    })
  },

  // 发送好友列表
  sendFriendMessage(data) {
    return httpRequestServer({
      method: 'POST',
      url: '/api/client/sendFriendMessage',
      data: data
    })
  },

  // 获取好友消息列表
  queryFriendMessage(data) {
    return httpRequestServer({
      method: 'POST',
      url: '/api/client/queryFriendMessage',
      data: data
    })
  },

  // 查看是否是好友
  chickIsFriend(data) {
    return httpRequestServer({
      method: 'GET',
      url: '/api/client/chickIsFriend',
      params: data
    })
  },

  // 添加为好友
  addUserFriend(data) {
    return httpRequestServer({
      method: 'POST',
      url: '/api/client/addFriend',
      data: data
    })
  },

  // 跟新用户的聊天状态
  setInchatStatus(data) {
    return httpRequestServer({
      method: 'PUT',
      url: '/api/client/setInchatStatus',
      data: data
    })
  }
}
<file_sep>/src/permission.js
import router from './router'
import store from './store'
import tokenServer from '@/server/token/index.js' // get token from cookie

const whiteList = ['/login', '/registe'] // no redirect whitelist

router.beforeEach((to, from, next) => {
  // determine whether the user has logged in
  const hasToken = tokenServer.getToken()

  if (hasToken) {
    if (to.path === '/login') {
      next({
        path: '/'
      })
    } else {
      // 刷新的时候 store 被重置，要重新请求用户信息数据  需要权限可以在这里添加权限控制
      const hasInfo = store.getters.userId
      if (hasInfo) {
        next()
      } else {
        store.dispatch('user/GetUserInfo', {
          mobile: hasToken
        }).then(() => {
          next() // dispatch 同步store之后再执行后续操作
        })
      }
    }
  } else {
    /* has no token*/

    if (whiteList.indexOf(to.path) !== -1) {
      // in the free login whitelist, go directly
      next()
    } else {
      // other pages that do not have permission to access are redirected to the login page.
      next(`/login?redirect=${to.path}`)
    }
  }
})
<file_sep>/src/store/modules/user.js
import {
  userModel
} from '@/http/index'
import {
  modalMessageServer,
  modalAlertServer
} from '@/server/modals/index'
import tokenServer from '@/server/token'

const state = {
  mobile: '',
  nickname: '',
  avatar: '',
  email: '',
  rule: [],
  token: '',
  userInfo: {}
}

const mutations = {
  SET_MOBILE: (state, name) => {
    state.mobile = name
  },
  SET_NICKNAME: (state, name) => {
    state.nickname = name
  },
  SET_AVATAR: (state, avatar) => {
    state.avatar = avatar
  },
  SET_EMAIL: (state, email) => {
    state.email = email
  },
  SET_USERINFO: (state, userInfo) => {
    state.userInfo = userInfo
  },
  SET_TOKEN: (state, token) => {
    state.token = token
  }
}

const actions = {
  // 登录
  Login({
    commit
  }, payload) {
    return new Promise((resolve, reject) => {
      userModel.userLogin({
        mobile: payload.mobile.trim(),
        password: <PASSWORD>.trim()
      }).then((data) => {
        if (data.statusCode === 200) {
          commit('SET_MOBILE', data.data.mobile)
          commit('SET_NICKNAME', data.data.nickname)
          commit('SET_AVATAR', data.data.avatar)
          commit('SET_EMAIL', data.data.email)
          commit('SET_USERINFO', data.data)
          commit('SET_TOKEN', data.data.mobile)
          tokenServer.setToken(data.data.mobile)
          resolve(data)
        } else if (data.statusCode === 111) {
          modalMessageServer.show(data.message, 1000)
        } else if (data.statusCode === 413) {
          modalMessageServer.show('验证码错误，请重试', 1000)
        } else {
          modalAlertServer.use({
            content: data.message
          })
        }
      }).catch(error => {
        reject(error)
      })
    })
  },
  // 获取用户信息
  GetUserInfo({
    commit
  }, payload) {
    return new Promise((resolve, reject) => {
      userModel.getUserInfo({
        mobile: payload.mobile.trim()
      }).then((data) => {
        if (data.statusCode === 200) {
          commit('SET_MOBILE', data.data.mobile)
          commit('SET_NICKNAME', data.data.nickname)
          commit('SET_AVATAR', data.data.avatar)
          commit('SET_EMAIL', data.data.email)
          commit('SET_USERINFO', data.data)
          commit('SET_TOKEN', data.data.mobile)
          tokenServer.setToken(data.data.mobile)
          resolve(data)
        } else if (data.statusCode === 111) {
          modalMessageServer.show(data.message, 1000)
        } else if (data.statusCode === 413) {
          modalMessageServer.show('验证码错误，请重试', 1000)
        } else {
          modalAlertServer.use({
            content: data.message
          })
        }
      }).catch(error => {
        reject(error)
      })
    })
  },
  // 退出登录
  Logout({
    commit
  }) {
    return new Promise((resolve, reject) => {
      userModel.outUser().then((data) => {
        if (data.statusCode === 200) {
          commit('SET_TOKEN', '')
          tokenServer.removeToken()
          resolve(data)
        } else {
          modalAlertServer.use({
            content: data.message
          })
        }
      }).catch(error => {
        reject(error)
      })
    })
  }
}

export default {
  namespaced: true,
  state,
  mutations,
  actions
}
<file_sep>/src/lib/provinceCode.js

export default {
  '110000': {
    province: '北京市',
    code: '110000'
  },
  '120000': {
    province: '天津市',
    code: '120000'
  },
  '130000': {
    province: '河北省',
    code: '130000'
  },
  '140000': {
    province: '山西省',
    code: '140000'
  },
  '150000': {
    province: '内蒙古自治区',
    code: '150000'
  },
  '210000': {
    province: '辽宁省',
    code: '210000'
  },
  '220000': {
    province: '吉林省',
    code: '220000'
  },
  '230000': {
    province: '黑龙江省',
    code: '230000'
  },
  '310000': {
    province: '上海市',
    code: '310000'
  },
  '320000': {
    province: '江苏省',
    code: '320000'
  },
  '330000': {
    province: '浙江省',
    code: '330000'
  },
  '340000': {
    province: '安徽省',
    code: '340000'
  },
  '350000': {
    province: '福建省',
    code: '350000'
  },
  '360000': {
    province: '江西省',
    code: '360000'
  },
  '370000': {
    province: '山东省',
    code: '370000'
  },
  '410000': {
    province: '河南省',
    code: '410000'
  },
  '420000': {
    province: '湖北省',
    code: '420000'
  },
  '430000': {
    province: '湖南省',
    code: '430000'
  },
  '440000': {
    province: '广东省',
    code: '440000'
  },
  '450000': {
    province: '广西壮族自治区',
    code: '450000'
  },
  '460000': {
    province: '海南省',
    code: '460000'
  },
  '500000': {
    province: '重庆市',
    code: '500000'
  },
  '510000': {
    province: '四川省',
    code: '510000'
  },
  '520000': {
    province: '贵州省',
    code: '520000'
  },
  '530000': {
    province: '云南省',
    code: '530000'
  },
  '540000': {
    province: '西藏自治区',
    code: '540000'
  },
  '610000': {
    province: '陕西省',
    code: '610000'
  },
  '620000': {
    province: '甘肃省',
    code: '620000'
  },
  '630000': {
    province: '青海省',
    code: '630000'
  },
  '640000': {
    province: '宁夏回族自治区',
    code: '640000'
  },
  '650000': {
    province: '新疆维吾尔自治区',
    code: '650000'
  },
  '710000': {
    province: '台湾省',
    code: '710000'
  },
  '810000': {
    province: '香港特别行政区',
    code: '810000'
  },
  '820000': {
    province: '澳门特别行政区',
    code: '820000'
  },
  '990000': {
    province: '国外地区',
    code: '990000'
  }
}

<file_sep>/src/server/modals/message/index.js
/* eslint-disable */
import Vue from 'vue'
import MessageComponent from './main.vue'

// 组件初始化的实例
var messageInstance = false

// 组件添加初始化挂载方法
MessageComponent.installMessage = function() {
  if (messageInstance) {
    return messageInstance
  }
  var message = Vue.extend(MessageComponent)
  var component = new message({}).$mount()
  document.querySelector('body').appendChild(component.$el)

  messageInstance = component
  // 把实例返回出来
  return messageInstance
}

/** ***********   组件服务   ****************/

// 将组件实例赋给服务 使用函数调用组件方法
var MessageServer = function() {
  this.instance = MessageComponent.installMessage()
}

// 组件服务方法
MessageServer.prototype.show = function(message, delayTime) {
  if (!this.instance) {
    this.instance = MessageComponent.installMessage()
  }
  this.instance.show(message, delayTime)
}

var modalMessageServer = new MessageServer()

export default modalMessageServer

<file_sep>/src/utils/index.js
/**
 * 初始化页面根元素字体大小
 * @param {Number} designWidth 设计稿宽度
 * @param {Number} baseFontSize 默认初始化字体大小
 */
function initFontSize(designWidth, baseFontSize) {
  designWidth = designWidth || 750
  baseFontSize = baseFontSize || 100
  // 根据客户端宽度、设计稿宽度和初始化字体大小，计算并设置根元素字体大小
  function calculateFontSize() {
    var e = document.documentElement
    var t = e.clientWidth || 640
    e.style.fontSize = t / designWidth * baseFontSize + 'px'
  }

  calculateFontSize()

  // 监听页面分辨率改变事件
  window.addEventListener('orientationchange' in window ? 'orientationchange' : 'resize', calculateFontSize)
}

export {
  initFontSize
}
