init

.nuxt/App.js

@@ -0,0 +1,194 @@
+import Vue from 'vue'
+import { decode, parsePath, withoutBase, withoutTrailingSlash, normalizeURL } from 'ufo'
+
+import { getMatchedComponentsInstances, getChildrenComponentInstancesUsingFetch, promisify, globalHandleError, urlJoin, sanitizeComponent } from './utils'
+import NuxtError from '../layouts/error.vue'
+
+import '../node_modules/element-ui/lib/theme-chalk/index.css'
+
+import '../assets/iconfont/iconfont.css'
+
+import '../assets/css/reset.scss'
+
+import '../assets/css/common.scss'
+
+import '../assets/css/element.scss'
+
+import '../assets/css/flex-custom.scss'
+
+import _c991692a from '../layouts/blank_layout.vue'
+import _6f6c098b from '../layouts/default.vue'
+import _32b9add8 from '../layouts/product_builder_layout.vue'
+
+const layouts = { "_blank_layout": sanitizeComponent(_c991692a),"_default": sanitizeComponent(_6f6c098b),"_product_builder_layout": sanitizeComponent(_32b9add8) }
+
+export default {
+  render (h, props) {
+    const layoutEl = h(this.layout || 'nuxt')
+    const templateEl = h('div', {
+      domProps: {
+        id: '__layout'
+      },
+      key: this.layoutName
+    }, [layoutEl])
+
+    const transitionEl = h('transition', {
+      props: {
+        name: 'layout',
+        mode: 'out-in'
+      },
+      on: {
+        beforeEnter (el) {
+          // Ensure to trigger scroll event after calling scrollBehavior
+          window.$nuxt.$nextTick(() => {
+            window.$nuxt.$emit('triggerScroll')
+          })
+        }
+      }
+    }, [templateEl])
+
+    return h('div', {
+      domProps: {
+        id: '__nuxt'
+      }
+    }, [
+
+      transitionEl
+    ])
+  },
+
+  data: () => ({
+    isOnline: true,
+
+    layout: null,
+    layoutName: '',
+
+    nbFetching: 0
+    }),
+
+  beforeCreate () {
+    Vue.util.defineReactive(this, 'nuxt', this.$options.nuxt)
+  },
+  created () {
+    // Add this.$nuxt in child instances
+    this.$root.$options.$nuxt = this
+
+    if (process.client) {
+      // add to window so we can listen when ready
+      window.$nuxt = this
+
+      this.refreshOnlineStatus()
+      // Setup the listeners
+      window.addEventListener('online', this.refreshOnlineStatus)
+      window.addEventListener('offline', this.refreshOnlineStatus)
+    }
+    // Add $nuxt.error()
+    this.error = this.nuxt.error
+    // Add $nuxt.context
+    this.context = this.$options.context
+  },
+
+  watch: {
+    'nuxt.err': 'errorChanged'
+  },
+
+  computed: {
+    isOffline () {
+      return !this.isOnline
+    },
+
+    isFetching () {
+      return this.nbFetching > 0
+    },
+  },
+
+  methods: {
+    refreshOnlineStatus () {
+      if (process.client) {
+        if (typeof window.navigator.onLine === 'undefined') {
+          // If the browser doesn't support connection status reports
+          // assume that we are online because most apps' only react
+          // when they now that the connection has been interrupted
+          this.isOnline = true
+        } else {
+          this.isOnline = window.navigator.onLine
+        }
+      }
+    },
+
+    async refresh () {
+      const pages = getMatchedComponentsInstances(this.$route)
+
+      if (!pages.length) {
+        return
+      }
+
+      const promises = pages.map(async (page) => {
+        let p = []
+
+        // Old fetch
+        if (page.$options.fetch && page.$options.fetch.length) {
+          p.push(promisify(page.$options.fetch, this.context))
+        }
+
+        if (page.$options.asyncData) {
+          p.push(
+            promisify(page.$options.asyncData, this.context)
+              .then((newData) => {
+                for (const key in newData) {
+                  Vue.set(page.$data, key, newData[key])
+                }
+              })
+          )
+        }
+
+        // Wait for asyncData & old fetch to finish
+        await Promise.all(p)
+        // Cleanup refs
+        p = []
+
+        if (page.$fetch) {
+          p.push(page.$fetch())
+        }
+        // Get all component instance to call $fetch
+        for (const component of getChildrenComponentInstancesUsingFetch(page.$vnode.componentInstance)) {
+          p.push(component.$fetch())
+        }
+
+        return Promise.all(p)
+      })
+      try {
+        await Promise.all(promises)
+      } catch (error) {
+        globalHandleError(error)
+        this.error(error)
+      }
+    },
+    errorChanged () {
+      if (this.nuxt.err) {
+        let errorLayout = (NuxtError.options || NuxtError).layout;
+
+        if (typeof errorLayout === 'function') {
+          errorLayout = errorLayout(this.context)
+        }
+
+        this.setLayout(errorLayout)
+      }
+    },
+
+    setLayout (layout) {
+      if (!layout || !layouts['_' + layout]) {
+        layout = 'default'
+      }
+      this.layoutName = layout
+      this.layout = layouts['_' + layout]
+      return this.layout
+    },
+    loadLayout (layout) {
+      if (!layout || !layouts['_' + layout]) {
+        layout = 'default'
+      }
+      return Promise.resolve(layouts['_' + layout])
+    },
+  },
+}

.nuxt/axios.js

@@ -0,0 +1,193 @@
+import Axios from 'axios'
+import defu from 'defu'
+
+// Axios.prototype cannot be modified
+const axiosExtra = {
+  setBaseURL (baseURL) {
+    this.defaults.baseURL = baseURL
+  },
+  setHeader (name, value, scopes = 'common') {
+    for (const scope of Array.isArray(scopes) ? scopes : [ scopes ]) {
+      if (!value) {
+        delete this.defaults.headers[scope][name];
+        continue
+      }
+      this.defaults.headers[scope][name] = value
+    }
+  },
+  setToken (token, type, scopes = 'common') {
+    const value = !token ? null : (type ? type + ' ' : '') + token
+    this.setHeader('Authorization', value, scopes)
+  },
+  onRequest(fn) {
+    this.interceptors.request.use(config => fn(config) || config)
+  },
+  onResponse(fn) {
+    this.interceptors.response.use(response => fn(response) || response)
+  },
+  onRequestError(fn) {
+    this.interceptors.request.use(undefined, error => fn(error) || Promise.reject(error))
+  },
+  onResponseError(fn) {
+    this.interceptors.response.use(undefined, error => fn(error) || Promise.reject(error))
+  },
+  onError(fn) {
+    this.onRequestError(fn)
+    this.onResponseError(fn)
+  },
+  create(options) {
+    return createAxiosInstance(defu(options, this.defaults))
+  }
+}
+
+// Request helpers ($get, $post, ...)
+for (const method of ['request', 'delete', 'get', 'head', 'options', 'post', 'put', 'patch']) {
+  axiosExtra['$' + method] = function () { return this[method].apply(this, arguments).then(res => res && res.data) }
+}
+
+const extendAxiosInstance = axios => {
+  for (const key in axiosExtra) {
+    axios[key] = axiosExtra[key].bind(axios)
+  }
+}
+
+const createAxiosInstance = axiosOptions => {
+  // Create new axios instance
+  const axios = Axios.create(axiosOptions)
+  axios.CancelToken = Axios.CancelToken
+  axios.isCancel = Axios.isCancel
+
+  // Extend axios proto
+  extendAxiosInstance(axios)
+
+  // Intercept to apply default headers
+  axios.onRequest((config) => {
+    config.headers = { ...axios.defaults.headers.common, ...config.headers }
+  })
+
+  // Setup interceptors
+
+  setupProgress(axios)
+
+  return axios
+}
+
+const setupProgress = (axios) => {
+  if (process.server) {
+    return
+  }
+
+  // A noop loading inteterface for when $nuxt is not yet ready
+  const noopLoading = {
+    finish: () => { },
+    start: () => { },
+    fail: () => { },
+    set: () => { }
+  }
+
+  const $loading = () => {
+    const $nuxt = typeof window !== 'undefined' && window['$nuxt']
+    return ($nuxt && $nuxt.$loading && $nuxt.$loading.set) ? $nuxt.$loading : noopLoading
+  }
+
+  let currentRequests = 0
+
+  axios.onRequest(config => {
+    if (config && config.progress === false) {
+      return
+    }
+
+    currentRequests++
+  })
+
+  axios.onResponse(response => {
+    if (response && response.config && response.config.progress === false) {
+      return
+    }
+
+    currentRequests--
+    if (currentRequests <= 0) {
+      currentRequests = 0
+      $loading().finish()
+    }
+  })
+
+  axios.onError(error => {
+    if (error && error.config && error.config.progress === false) {
+      return
+    }
+
+    currentRequests--
+
+    if (Axios.isCancel(error)) {
+      if (currentRequests <= 0) {
+        currentRequests = 0
+        $loading().finish()
+      }
+      return
+    }
+
+    $loading().fail()
+    $loading().finish()
+  })
+
+  const onProgress = e => {
+    if (!currentRequests || !e.total) {
+      return
+    }
+    const progress = ((e.loaded * 100) / (e.total * currentRequests))
+    $loading().set(Math.min(100, progress))
+  }
+
+  axios.defaults.onUploadProgress = onProgress
+  axios.defaults.onDownloadProgress = onProgress
+}
+
+export default (ctx, inject) => {
+  // runtimeConfig
+  const runtimeConfig = ctx.$config && ctx.$config.axios || {}
+  // baseURL
+  const baseURL = process.browser
+    ? (runtimeConfig.browserBaseURL || runtimeConfig.browserBaseUrl || runtimeConfig.baseURL || runtimeConfig.baseUrl || '/')
+      : (runtimeConfig.baseURL || runtimeConfig.baseUrl || process.env._AXIOS_BASE_URL_ || 'http://localhost:3000/')
+
+  // Create fresh objects for all default header scopes
+  // Axios creates only one which is shared across SSR requests!
+  // https://github.com/mzabriskie/axios/blob/master/lib/defaults.js
+  const headers = {
+    "common": {
+        "Accept": "application/json, text/plain, */*"
+    },
+    "delete": {},
+    "get": {},
+    "head": {},
+    "post": {},
+    "put": {},
+    "patch": {}
+}
+
+  const axiosOptions = {
+    baseURL,
+    headers
+  }
+
+  // Proxy SSR request headers headers
+  if (process.server && ctx.req && ctx.req.headers) {
+    const reqHeaders = { ...ctx.req.headers }
+    for (const h of ["accept","cf-connecting-ip","cf-ray","content-length","content-md5","content-type","host","x-forwarded-host","x-forwarded-port","x-forwarded-proto"]) {
+      delete reqHeaders[h]
+    }
+    axiosOptions.headers.common = { ...reqHeaders, ...axiosOptions.headers.common }
+  }
+
+  if (process.server) {
+    // Don't accept brotli encoding because Node can't parse it
+    axiosOptions.headers.common['accept-encoding'] = 'gzip, deflate'
+  }
+
+  const axios = createAxiosInstance(axiosOptions)
+
+  // Inject axios to the context as $axios
+  ctx.$axios = axios
+  inject('axios', axios)
+}

.nuxt/client.js

@@ -0,0 +1,617 @@
+import Vue from 'vue'
+import fetch from 'unfetch'
+import middleware from './middleware.js'
+import {
+  applyAsyncData,
+  promisify,
+  middlewareSeries,
+  sanitizeComponent,
+  resolveRouteComponents,
+  getMatchedComponents,
+  getMatchedComponentsInstances,
+  flatMapComponents,
+  setContext,
+  getLocation,
+  compile,
+  getQueryDiff,
+  globalHandleError,
+  isSamePath,
+  urlJoin
+} from './utils.js'
+import { createApp, NuxtError } from './index.js'
+import fetchMixin from './mixins/fetch.client'
+import NuxtLink from './components/nuxt-link.client.js' // should be included after ./index.js
+
+// Fetch mixin
+if (!Vue.__nuxt__fetch__mixin__) {
+  Vue.mixin(fetchMixin)
+  Vue.__nuxt__fetch__mixin__ = true
+}
+
+// Component: <NuxtLink>
+Vue.component(NuxtLink.name, NuxtLink)
+Vue.component('NLink', NuxtLink)
+
+if (!global.fetch) { global.fetch = fetch }
+
+// Global shared references
+let _lastPaths = []
+let app
+let router
+let store
+
+// Try to rehydrate SSR data from window
+const NUXT = window.__NUXT__ || {}
+
+const $config = NUXT.config || {}
+if ($config._app) {
+  __webpack_public_path__ = urlJoin($config._app.cdnURL, $config._app.assetsPath)
+}
+
+Object.assign(Vue.config, {"silent":true,"performance":false})
+
+const errorHandler = Vue.config.errorHandler || console.error
+
+// Create and mount App
+createApp(null, NUXT.config).then(mountApp).catch(errorHandler)
+
+function componentOption (component, key, ...args) {
+  if (!component || !component.options || !component.options[key]) {
+    return {}
+  }
+  const option = component.options[key]
+  if (typeof option === 'function') {
+    return option(...args)
+  }
+  return option
+}
+
+function mapTransitions (toComponents, to, from) {
+  const componentTransitions = (component) => {
+    const transition = componentOption(component, 'transition', to, from) || {}
+    return (typeof transition === 'string' ? { name: transition } : transition)
+  }
+
+  const fromComponents = from ? getMatchedComponents(from) : []
+  const maxDepth = Math.max(toComponents.length, fromComponents.length)
+
+  const mergedTransitions = []
+  for (let i=0; i<maxDepth; i++) {
+    // Clone original objects to prevent overrides
+    const toTransitions = Object.assign({}, componentTransitions(toComponents[i]))
+    const transitions = Object.assign({}, componentTransitions(fromComponents[i]))
+
+    // Combine transitions & prefer `leave` properties of "from" route
+    Object.keys(toTransitions)
+        .filter(key => typeof toTransitions[key] !== 'undefined' && !key.toLowerCase().includes('leave'))
+        .forEach((key) => { transitions[key] = toTransitions[key] })
+
+    mergedTransitions.push(transitions)
+  }
+  return mergedTransitions
+}
+
+async function loadAsyncComponents (to, from, next) {
+  // Check if route changed (this._routeChanged), only if the page is not an error (for validate())
+  this._routeChanged = Boolean(app.nuxt.err) || from.name !== to.name
+  this._paramChanged = !this._routeChanged && from.path !== to.path
+  this._queryChanged = !this._paramChanged && from.fullPath !== to.fullPath
+  this._diffQuery = (this._queryChanged ? getQueryDiff(to.query, from.query) : [])
+
+  try {
+    if (this._queryChanged) {
+      const Components = await resolveRouteComponents(
+        to,
+        (Component, instance) => ({ Component, instance })
+      )
+      // Add a marker on each component that it needs to refresh or not
+      const startLoader = Components.some(({ Component, instance }) => {
+        const watchQuery = Component.options.watchQuery
+        if (watchQuery === true) {
+          return true
+        }
+        if (Array.isArray(watchQuery)) {
+          return watchQuery.some(key => this._diffQuery[key])
+        }
+        if (typeof watchQuery === 'function') {
+          return watchQuery.apply(instance, [to.query, from.query])
+        }
+        return false
+      })
+    }
+    // Call next()
+    next()
+  } catch (error) {
+    const err = error || {}
+    const statusCode = err.statusCode || err.status || (err.response && err.response.status) || 500
+    const message = err.message || ''
+
+    // Handle chunk loading errors
+    // This may be due to a new deployment or a network problem
+    if (/^Loading( CSS)? chunk (\d)+ failed\./.test(message)) {
+      window.location.reload(true /* skip cache */)
+      return // prevent error page blinking for user
+    }
+
+    this.error({ statusCode, message })
+    this.$nuxt.$emit('routeChanged', to, from, err)
+    next()
+  }
+}
+
+function applySSRData (Component, ssrData) {
+  if (NUXT.serverRendered && ssrData) {
+    applyAsyncData(Component, ssrData)
+  }
+
+  Component._Ctor = Component
+  return Component
+}
+
+// Get matched components
+function resolveComponents (route) {
+  return flatMapComponents(route, async (Component, _, match, key, index) => {
+    // If component is not resolved yet, resolve it
+    if (typeof Component === 'function' && !Component.options) {
+      Component = await Component()
+    }
+    // Sanitize it and save it
+    const _Component = applySSRData(sanitizeComponent(Component), NUXT.data ? NUXT.data[index] : null)
+    match.components[key] = _Component
+    return _Component
+  })
+}
+
+function callMiddleware (Components, context, layout) {
+  let midd = ["redirect"]
+  let unknownMiddleware = false
+
+  // If layout is undefined, only call global middleware
+  if (typeof layout !== 'undefined') {
+    midd = [] // Exclude global middleware if layout defined (already called before)
+    layout = sanitizeComponent(layout)
+    if (layout.options.middleware) {
+      midd = midd.concat(layout.options.middleware)
+    }
+    Components.forEach((Component) => {
+      if (Component.options.middleware) {
+        midd = midd.concat(Component.options.middleware)
+      }
+    })
+  }
+
+  midd = midd.map((name) => {
+    if (typeof name === 'function') {
+      return name
+    }
+    if (typeof middleware[name] !== 'function') {
+      unknownMiddleware = true
+      this.error({ statusCode: 500, message: 'Unknown middleware ' + name })
+    }
+    return middleware[name]
+  })
+
+  if (unknownMiddleware) {
+    return
+  }
+  return middlewareSeries(midd, context)
+}
+
+async function render (to, from, next) {
+  if (this._routeChanged === false && this._paramChanged === false && this._queryChanged === false) {
+    return next()
+  }
+  // Handle first render on SPA mode
+  let spaFallback = false
+  if (to === from) {
+    _lastPaths = []
+    spaFallback = true
+  } else {
+    const fromMatches = []
+    _lastPaths = getMatchedComponents(from, fromMatches).map((Component, i) => {
+      return compile(from.matched[fromMatches[i]].path)(from.params)
+    })
+  }
+
+  // nextCalled is true when redirected
+  let nextCalled = false
+  const _next = (path) => {
+    if (nextCalled) {
+      return
+    }
+
+    nextCalled = true
+    next(path)
+  }
+
+  // Update context
+  await setContext(app, {
+    route: to,
+    from,
+    next: _next.bind(this)
+  })
+  this._dateLastError = app.nuxt.dateErr
+  this._hadError = Boolean(app.nuxt.err)
+
+  // Get route's matched components
+  const matches = []
+  const Components = getMatchedComponents(to, matches)
+
+  // If no Components matched, generate 404
+  if (!Components.length) {
+    // Default layout
+    await callMiddleware.call(this, Components, app.context)
+    if (nextCalled) {
+      return
+    }
+
+    // Load layout for error page
+    const errorLayout = (NuxtError.options || NuxtError).layout
+    const layout = await this.loadLayout(
+      typeof errorLayout === 'function'
+        ? errorLayout.call(NuxtError, app.context)
+        : errorLayout
+    )
+
+    await callMiddleware.call(this, Components, app.context, layout)
+    if (nextCalled) {
+      return
+    }
+
+    // Show error page
+    app.context.error({ statusCode: 404, message: 'This page could not be found' })
+    return next()
+  }
+
+  // Update ._data and other properties if hot reloaded
+  Components.forEach((Component) => {
+    if (Component._Ctor && Component._Ctor.options) {
+      Component.options.asyncData = Component._Ctor.options.asyncData
+      Component.options.fetch = Component._Ctor.options.fetch
+    }
+  })
+
+  // Apply transitions
+  this.setTransitions(mapTransitions(Components, to, from))
+
+  try {
+    // Call middleware
+    await callMiddleware.call(this, Components, app.context)
+    if (nextCalled) {
+      return
+    }
+    if (app.context._errored) {
+      return next()
+    }
+
+    // Set layout
+    let layout = Components[0].options.layout
+    if (typeof layout === 'function') {
+      layout = layout(app.context)
+    }
+    layout = await this.loadLayout(layout)
+
+    // Call middleware for layout
+    await callMiddleware.call(this, Components, app.context, layout)
+    if (nextCalled) {
+      return
+    }
+    if (app.context._errored) {
+      return next()
+    }
+
+    // Call .validate()
+    let isValid = true
+    try {
+      for (const Component of Components) {
+        if (typeof Component.options.validate !== 'function') {
+          continue
+        }
+
+        isValid = await Component.options.validate(app.context)
+
+        if (!isValid) {
+          break
+        }
+      }
+    } catch (validationError) {
+      // ...If .validate() threw an error
+      this.error({
+        statusCode: validationError.statusCode || '500',
+        message: validationError.message
+      })
+      return next()
+    }
+
+    // ...If .validate() returned false
+    if (!isValid) {
+      this.error({ statusCode: 404, message: 'This page could not be found' })
+      return next()
+    }
+
+    let instances
+    // Call asyncData & fetch hooks on components matched by the route.
+    await Promise.all(Components.map(async (Component, i) => {
+      // Check if only children route changed
+      Component._path = compile(to.matched[matches[i]].path)(to.params)
+      Component._dataRefresh = false
+      const childPathChanged = Component._path !== _lastPaths[i]
+      // Refresh component (call asyncData & fetch) when:
+      // Route path changed part includes current component
+      // Or route param changed part includes current component and watchParam is not `false`
+      // Or route query is changed and watchQuery returns `true`
+      if (this._routeChanged && childPathChanged) {
+        Component._dataRefresh = true
+      } else if (this._paramChanged && childPathChanged) {
+        const watchParam = Component.options.watchParam
+        Component._dataRefresh = watchParam !== false
+      } else if (this._queryChanged) {
+        const watchQuery = Component.options.watchQuery
+        if (watchQuery === true) {
+          Component._dataRefresh = true
+        } else if (Array.isArray(watchQuery)) {
+          Component._dataRefresh = watchQuery.some(key => this._diffQuery[key])
+        } else if (typeof watchQuery === 'function') {
+          if (!instances) {
+            instances = getMatchedComponentsInstances(to)
+          }
+          Component._dataRefresh = watchQuery.apply(instances[i], [to.query, from.query])
+        }
+      }
+      if (!this._hadError && this._isMounted && !Component._dataRefresh) {
+        return
+      }
+
+      const promises = []
+
+      const hasAsyncData = (
+        Component.options.asyncData &&
+        typeof Component.options.asyncData === 'function'
+      )
+
+      const hasFetch = Boolean(Component.options.fetch) && Component.options.fetch.length
+
+      // Call asyncData(context)
+      if (hasAsyncData) {
+        const promise = promisify(Component.options.asyncData, app.context)
+
+        promise.then((asyncDataResult) => {
+          applyAsyncData(Component, asyncDataResult)
+        })
+        promises.push(promise)
+      }
+
+      // Check disabled page loading
+      this.$loading.manual = Component.options.loading === false
+
+      // Call fetch(context)
+      if (hasFetch) {
+        let p = Component.options.fetch(app.context)
+        if (!p || (!(p instanceof Promise) && (typeof p.then !== 'function'))) {
+          p = Promise.resolve(p)
+        }
+        p.then((fetchResult) => {
+        })
+        promises.push(p)
+      }
+
+      return Promise.all(promises)
+    }))
+
+    // If not redirected
+    if (!nextCalled) {
+      next()
+    }
+  } catch (err) {
+    const error = err || {}
+    if (error.message === 'ERR_REDIRECT') {
+      return this.$nuxt.$emit('routeChanged', to, from, error)
+    }
+    _lastPaths = []
+
+    globalHandleError(error)
+
+    // Load error layout
+    let layout = (NuxtError.options || NuxtError).layout
+    if (typeof layout === 'function') {
+      layout = layout(app.context)
+    }
+    await this.loadLayout(layout)
+
+    this.error(error)
+    this.$nuxt.$emit('routeChanged', to, from, error)
+    next()
+  }
+}
+
+// Fix components format in matched, it's due to code-splitting of vue-router
+function normalizeComponents (to, ___) {
+  flatMapComponents(to, (Component, _, match, key) => {
+    if (typeof Component === 'object' && !Component.options) {
+      // Updated via vue-router resolveAsyncComponents()
+      Component = Vue.extend(Component)
+      Component._Ctor = Component
+      match.components[key] = Component
+    }
+    return Component
+  })
+}
+
+function setLayoutForNextPage (to) {
+  // Set layout
+  let hasError = Boolean(this.$options.nuxt.err)
+  if (this._hadError && this._dateLastError === this.$options.nuxt.dateErr) {
+    hasError = false
+  }
+  let layout = hasError
+    ? (NuxtError.options || NuxtError).layout
+    : to.matched[0].components.default.options.layout
+
+  if (typeof layout === 'function') {
+    layout = layout(app.context)
+  }
+
+  this.setLayout(layout)
+}
+
+function checkForErrors (app) {
+  // Hide error component if no error
+  if (app._hadError && app._dateLastError === app.$options.nuxt.dateErr) {
+    app.error()
+  }
+}
+
+// When navigating on a different route but the same component is used, Vue.js
+// Will not update the instance data, so we have to update $data ourselves
+function fixPrepatch (to, ___) {
+  if (this._routeChanged === false && this._paramChanged === false && this._queryChanged === false) {
+    return
+  }
+
+  const instances = getMatchedComponentsInstances(to)
+  const Components = getMatchedComponents(to)
+
+  let triggerScroll = false
+
+  Vue.nextTick(() => {
+    instances.forEach((instance, i) => {
+      if (!instance || instance._isDestroyed) {
+        return
+      }
+
+      if (
+        instance.constructor._dataRefresh &&
+        Components[i] === instance.constructor &&
+        instance.$vnode.data.keepAlive !== true &&
+        typeof instance.constructor.options.data === 'function'
+      ) {
+        const newData = instance.constructor.options.data.call(instance)
+        for (const key in newData) {
+          Vue.set(instance.$data, key, newData[key])
+        }
+
+        triggerScroll = true
+      }
+    })
+
+    if (triggerScroll) {
+      // Ensure to trigger scroll event after calling scrollBehavior
+      window.$nuxt.$nextTick(() => {
+        window.$nuxt.$emit('triggerScroll')
+      })
+    }
+
+    checkForErrors(this)
+  })
+}
+
+function nuxtReady (_app) {
+  window.onNuxtReadyCbs.forEach((cb) => {
+    if (typeof cb === 'function') {
+      cb(_app)
+    }
+  })
+  // Special JSDOM
+  if (typeof window._onNuxtLoaded === 'function') {
+    window._onNuxtLoaded(_app)
+  }
+  // Add router hooks
+  router.afterEach((to, from) => {
+    // Wait for fixPrepatch + $data updates
+    Vue.nextTick(() => _app.$nuxt.$emit('routeChanged', to, from))
+  })
+}
+
+async function mountApp (__app) {
+  // Set global variables
+  app = __app.app
+  router = __app.router
+  store = __app.store
+
+  // Create Vue instance
+  const _app = new Vue(app)
+
+  // Load layout
+  const layout = NUXT.layout || 'default'
+  await _app.loadLayout(layout)
+  _app.setLayout(layout)
+
+  // Mounts Vue app to DOM element
+  const mount = () => {
+    _app.$mount('#__nuxt')
+
+    // Add afterEach router hooks
+    router.afterEach(normalizeComponents)
+
+    router.afterEach(setLayoutForNextPage.bind(_app))
+
+    router.afterEach(fixPrepatch.bind(_app))
+
+    // Listen for first Vue update
+    Vue.nextTick(() => {
+      // Call window.{{globals.readyCallback}} callbacks
+      nuxtReady(_app)
+    })
+  }
+
+  // Resolve route components
+  const Components = await Promise.all(resolveComponents(app.context.route))
+
+  // Enable transitions
+  _app.setTransitions = _app.$options.nuxt.setTransitions.bind(_app)
+  if (Components.length) {
+    _app.setTransitions(mapTransitions(Components, router.currentRoute))
+    _lastPaths = router.currentRoute.matched.map(route => compile(route.path)(router.currentRoute.params))
+  }
+
+  // Initialize error handler
+  _app.$loading = {} // To avoid error while _app.$nuxt does not exist
+  if (NUXT.error) {
+    _app.error(NUXT.error)
+  }
+
+  // Add beforeEach router hooks
+  router.beforeEach(loadAsyncComponents.bind(_app))
+  router.beforeEach(render.bind(_app))
+
+  // Fix in static: remove trailing slash to force hydration
+  // Full static, if server-rendered: hydrate, to allow custom redirect to generated page
+
+  // Fix in static: remove trailing slash to force hydration
+  if (NUXT.serverRendered && isSamePath(NUXT.routePath, _app.context.route.path)) {
+    return mount()
+  }
+
+  // First render on client-side
+  const clientFirstMount = () => {
+    normalizeComponents(router.currentRoute, router.currentRoute)
+    setLayoutForNextPage.call(_app, router.currentRoute)
+    checkForErrors(_app)
+    // Don't call fixPrepatch.call(_app, router.currentRoute, router.currentRoute) since it's first render
+    mount()
+  }
+
+  // fix: force next tick to avoid having same timestamp when an error happen on spa fallback
+  await new Promise(resolve => setTimeout(resolve, 0))
+  render.call(_app, router.currentRoute, router.currentRoute, (path) => {
+    // If not redirected
+    if (!path) {
+      clientFirstMount()
+      return
+    }
+
+    // Add a one-time afterEach hook to
+    // mount the app wait for redirect and route gets resolved
+    const unregisterHook = router.afterEach((to, from) => {
+      unregisterHook()
+      clientFirstMount()
+    })
+
+    // Push the path and let route to be resolved
+    router.push(path, undefined, (err) => {
+      if (err) {
+        errorHandler(err)
+      }
+    })
+  })
+}

.nuxt/components/index.js

@@ -0,0 +1,89 @@
+export const Breadcrumb = () => import('../../components/Breadcrumb.vue' /* webpackChunkName: "components/breadcrumb" */).then(c => wrapFunctional(c.default || c))
+export const Bxh = () => import('../../components/Bxh.vue' /* webpackChunkName: "components/bxh" */).then(c => wrapFunctional(c.default || c))
+export const Card = () => import('../../components/Card.vue' /* webpackChunkName: "components/card" */).then(c => wrapFunctional(c.default || c))
+export const Carousel = () => import('../../components/Carousel.vue' /* webpackChunkName: "components/carousel" */).then(c => wrapFunctional(c.default || c))
+export const CategoryFilter = () => import('../../components/CategoryFilter.vue' /* webpackChunkName: "components/category-filter" */).then(c => wrapFunctional(c.default || c))
+export const CategoryNoData = () => import('../../components/CategoryNoData.vue' /* webpackChunkName: "components/category-no-data" */).then(c => wrapFunctional(c.default || c))
+export const DIalogXXSuccess = () => import('../../components/DIalogXXSuccess.vue' /* webpackChunkName: "components/d-ialog-x-x-success" */).then(c => wrapFunctional(c.default || c))
+export const DesignFormDialog = () => import('../../components/DesignFormDialog.vue' /* webpackChunkName: "components/design-form-dialog" */).then(c => wrapFunctional(c.default || c))
+export const DownloadDialog = () => import('../../components/DownloadDialog.vue' /* webpackChunkName: "components/download-dialog" */).then(c => wrapFunctional(c.default || c))
+export const ExportDialog = () => import('../../components/ExportDialog.vue' /* webpackChunkName: "components/export-dialog" */).then(c => wrapFunctional(c.default || c))
+export const FormDialog = () => import('../../components/FormDialog.vue' /* webpackChunkName: "components/form-dialog" */).then(c => wrapFunctional(c.default || c))
+export const ImageUpload = () => import('../../components/ImageUpload.vue' /* webpackChunkName: "components/image-upload" */).then(c => wrapFunctional(c.default || c))
+export const Pagination = () => import('../../components/Pagination.vue' /* webpackChunkName: "components/pagination" */).then(c => wrapFunctional(c.default || c))
+export const PcArticle = () => import('../../components/PcArticle.vue' /* webpackChunkName: "components/pc-article" */).then(c => wrapFunctional(c.default || c))
+export const PcFooter = () => import('../../components/PcFooter.vue' /* webpackChunkName: "components/pc-footer" */).then(c => wrapFunctional(c.default || c))
+export const PcGlobalForm = () => import('../../components/PcGlobalForm.vue' /* webpackChunkName: "components/pc-global-form" */).then(c => wrapFunctional(c.default || c))
+export const PcHeader = () => import('../../components/PcHeader.vue' /* webpackChunkName: "components/pc-header" */).then(c => wrapFunctional(c.default || c))
+export const PcHeaderLite = () => import('../../components/PcHeaderLite.vue' /* webpackChunkName: "components/pc-header-lite" */).then(c => wrapFunctional(c.default || c))
+export const PcSwitch = () => import('../../components/PcSwitch.vue' /* webpackChunkName: "components/pc-switch" */).then(c => wrapFunctional(c.default || c))
+export const PcTitle = () => import('../../components/PcTitle.vue' /* webpackChunkName: "components/pc-title" */).then(c => wrapFunctional(c.default || c))
+export const PdfHtml = () => import('../../components/PdfHtml.vue' /* webpackChunkName: "components/pdf-html" */).then(c => wrapFunctional(c.default || c))
+export const PriceToImg = () => import('../../components/PriceToImg.vue' /* webpackChunkName: "components/price-to-img" */).then(c => wrapFunctional(c.default || c))
+export const Project = () => import('../../components/Project.vue' /* webpackChunkName: "components/project" */).then(c => wrapFunctional(c.default || c))
+export const ProjectDialog = () => import('../../components/ProjectDialog.vue' /* webpackChunkName: "components/project-dialog" */).then(c => wrapFunctional(c.default || c))
+export const ResetPasswordMail = () => import('../../components/ResetPasswordMail.vue' /* webpackChunkName: "components/reset-password-mail" */).then(c => wrapFunctional(c.default || c))
+export const RowCard = () => import('../../components/RowCard.vue' /* webpackChunkName: "components/row-card" */).then(c => wrapFunctional(c.default || c))
+export const SubNav = () => import('../../components/SubNav.vue' /* webpackChunkName: "components/sub-nav" */).then(c => wrapFunctional(c.default || c))
+export const Subscription = () => import('../../components/Subscription.vue' /* webpackChunkName: "components/subscription" */).then(c => wrapFunctional(c.default || c))
+export const TabNav = () => import('../../components/TabNav.vue' /* webpackChunkName: "components/tab-nav" */).then(c => wrapFunctional(c.default || c))
+export const Zoom = () => import('../../components/Zoom.vue' /* webpackChunkName: "components/zoom" */).then(c => wrapFunctional(c.default || c))
+export const AddAddressDialog = () => import('../../components/addAddressDialog.vue' /* webpackChunkName: "components/add-address-dialog" */).then(c => wrapFunctional(c.default || c))
+export const BookCard = () => import('../../components/bookCard.vue' /* webpackChunkName: "components/book-card" */).then(c => wrapFunctional(c.default || c))
+export const ImageList = () => import('../../components/imageList.vue' /* webpackChunkName: "components/image-list" */).then(c => wrapFunctional(c.default || c))
+export const LoginDialog = () => import('../../components/loginDialog.vue' /* webpackChunkName: "components/login-dialog" */).then(c => wrapFunctional(c.default || c))
+export const ResetPasswordDialog = () => import('../../components/resetPasswordDialog.vue' /* webpackChunkName: "components/reset-password-dialog" */).then(c => wrapFunctional(c.default || c))
+export const TinymceDynamicLoadScript = () => import('../../components/Tinymce/dynamicLoadScript.js' /* webpackChunkName: "components/tinymce-dynamic-load-script" */).then(c => wrapFunctional(c.default || c))
+export const Tinymce = () => import('../../components/Tinymce/index.vue' /* webpackChunkName: "components/tinymce" */).then(c => wrapFunctional(c.default || c))
+export const TinymcePlugins = () => import('../../components/Tinymce/plugins.js' /* webpackChunkName: "components/tinymce-plugins" */).then(c => wrapFunctional(c.default || c))
+export const TinymceToolbar = () => import('../../components/Tinymce/toolbar.js' /* webpackChunkName: "components/tinymce-toolbar" */).then(c => wrapFunctional(c.default || c))
+export const ProductLeft = () => import('../../components/product/ProductLeft.vue' /* webpackChunkName: "components/product-left" */).then(c => wrapFunctional(c.default || c))
+export const ProductRight = () => import('../../components/product/ProductRight.vue' /* webpackChunkName: "components/product-right" */).then(c => wrapFunctional(c.default || c))
+export const ProductQuote = () => import('../../components/product/Quote.vue' /* webpackChunkName: "components/product-quote" */).then(c => wrapFunctional(c.default || c))
+export const CustomElSliderButton = () => import('../../components/custom-el-slider/button.vue' /* webpackChunkName: "components/custom-el-slider-button" */).then(c => wrapFunctional(c.default || c))
+export const CustomElSlider = () => import('../../components/custom-el-slider/index.vue' /* webpackChunkName: "components/custom-el-slider" */).then(c => wrapFunctional(c.default || c))
+export const CustomElSliderMarker = () => import('../../components/custom-el-slider/marker.vue' /* webpackChunkName: "components/custom-el-slider-marker" */).then(c => wrapFunctional(c.default || c))
+export const ProductBuilderDialogSelectAddr = () => import('../../components/product-builder/DialogSelectAddr.vue' /* webpackChunkName: "components/product-builder-dialog-select-addr" */).then(c => wrapFunctional(c.default || c))
+export const ProductBuilderStep1 = () => import('../../components/product-builder/step-1.vue' /* webpackChunkName: "components/product-builder-step1" */).then(c => wrapFunctional(c.default || c))
+export const ProductBuilderStep2 = () => import('../../components/product-builder/step-2.vue' /* webpackChunkName: "components/product-builder-step2" */).then(c => wrapFunctional(c.default || c))
+export const ProductBuilderStep3 = () => import('../../components/product-builder/step-3.vue' /* webpackChunkName: "components/product-builder-step3" */).then(c => wrapFunctional(c.default || c))
+export const ProductBuilderStepMixin = () => import('../../components/product-builder/stepMixin.vue' /* webpackChunkName: "components/product-builder-step-mixin" */).then(c => wrapFunctional(c.default || c))
+export const TableChangeTable = () => import('../../components/table/ChangeTable.vue' /* webpackChunkName: "components/table-change-table" */).then(c => wrapFunctional(c.default || c))
+export const TableMailTable = () => import('../../components/table/MailTable.vue' /* webpackChunkName: "components/table-mail-table" */).then(c => wrapFunctional(c.default || c))
+export const TableNewPriceTable = () => import('../../components/table/NewPriceTable.vue' /* webpackChunkName: "components/table-new-price-table" */).then(c => wrapFunctional(c.default || c))
+export const TableStockTable = () => import('../../components/table/StockTable.vue' /* webpackChunkName: "components/table-stock-table" */).then(c => wrapFunctional(c.default || c))
+export const TableTotalTable = () => import('../../components/table/TotalTable.vue' /* webpackChunkName: "components/table-total-table" */).then(c => wrapFunctional(c.default || c))
+export const TableUnitTable = () => import('../../components/table/UnitTable.vue' /* webpackChunkName: "components/table-unit-table" */).then(c => wrapFunctional(c.default || c))
+export const TableParamTable = () => import('../../components/table/paramTable.vue' /* webpackChunkName: "components/table-param-table" */).then(c => wrapFunctional(c.default || c))
+export const TinymceComponentsEditorImage = () => import('../../components/Tinymce/components/EditorImage.vue' /* webpackChunkName: "components/tinymce-components-editor-image" */).then(c => wrapFunctional(c.default || c))
+
+// nuxt/nuxt.js#8607
+function wrapFunctional(options) {
+  if (!options || !options.functional) {
+    return options
+  }
+
+  const propKeys = Array.isArray(options.props) ? options.props : Object.keys(options.props || {})
+
+  return {
+    render(h) {
+      const attrs = {}
+      const props = {}
+
+      for (const key in this.$attrs) {
+        if (propKeys.includes(key)) {
+          props[key] = this.$attrs[key]
+        } else {
+          attrs[key] = this.$attrs[key]
+        }
+      }
+
+      return h(options, {
+        on: this.$listeners,
+        attrs,
+        props,
+        scopedSlots: this.$scopedSlots,
+      }, this.$slots.default)
+    }
+  }
+}

.nuxt/components/nuxt-child.js

@@ -0,0 +1,121 @@
+export default {
+  name: 'NuxtChild',
+  functional: true,
+  props: {
+    nuxtChildKey: {
+      type: String,
+      default: ''
+    },
+    keepAlive: Boolean,
+    keepAliveProps: {
+      type: Object,
+      default: undefined
+    }
+  },
+  render (_, { parent, data, props }) {
+    const h = parent.$createElement
+
+    data.nuxtChild = true
+    const _parent = parent
+    const transitions = parent.$nuxt.nuxt.transitions
+    const defaultTransition = parent.$nuxt.nuxt.defaultTransition
+
+    let depth = 0
+    while (parent) {
+      if (parent.$vnode && parent.$vnode.data.nuxtChild) {
+        depth++
+      }
+      parent = parent.$parent
+    }
+    data.nuxtChildDepth = depth
+    const transition = transitions[depth] || defaultTransition
+    const transitionProps = {}
+    transitionsKeys.forEach((key) => {
+      if (typeof transition[key] !== 'undefined') {
+        transitionProps[key] = transition[key]
+      }
+    })
+
+    const listeners = {}
+    listenersKeys.forEach((key) => {
+      if (typeof transition[key] === 'function') {
+        listeners[key] = transition[key].bind(_parent)
+      }
+    })
+    if (process.client) {
+      // Add triggerScroll event on beforeEnter (fix #1376)
+      const beforeEnter = listeners.beforeEnter
+      listeners.beforeEnter = (el) => {
+        // Ensure to trigger scroll event after calling scrollBehavior
+        window.$nuxt.$nextTick(() => {
+          window.$nuxt.$emit('triggerScroll')
+        })
+        if (beforeEnter) {
+          return beforeEnter.call(_parent, el)
+        }
+      }
+    }
+
+    // make sure that leave is called asynchronous (fix #5703)
+    if (transition.css === false) {
+      const leave = listeners.leave
+
+      // only add leave listener when user didnt provide one
+      // or when it misses the done argument
+      if (!leave || leave.length < 2) {
+        listeners.leave = (el, done) => {
+          if (leave) {
+            leave.call(_parent, el)
+          }
+
+          _parent.$nextTick(done)
+        }
+      }
+    }
+
+    let routerView = h('routerView', data)
+
+    if (props.keepAlive) {
+      routerView = h('keep-alive', { props: props.keepAliveProps }, [routerView])
+    }
+
+    return h('transition', {
+      props: transitionProps,
+      on: listeners
+    }, [routerView])
+  }
+}
+
+const transitionsKeys = [
+  'name',
+  'mode',
+  'appear',
+  'css',
+  'type',
+  'duration',
+  'enterClass',
+  'leaveClass',
+  'appearClass',
+  'enterActiveClass',
+  'enterActiveClass',
+  'leaveActiveClass',
+  'appearActiveClass',
+  'enterToClass',
+  'leaveToClass',
+  'appearToClass'
+]
+
+const listenersKeys = [
+  'beforeEnter',
+  'enter',
+  'afterEnter',
+  'enterCancelled',
+  'beforeLeave',
+  'leave',
+  'afterLeave',
+  'leaveCancelled',
+  'beforeAppear',
+  'appear',
+  'afterAppear',
+  'appearCancelled'
+]

.nuxt/components/nuxt-error.vue

@@ -0,0 +1,96 @@
+<template>
+  <div class="__nuxt-error-page">
+    <div class="error">
+      <svg xmlns="http://www.w3.org/2000/svg" width="90" height="90" fill="#DBE1EC" viewBox="0 0 48 48">
+        <path d="M22 30h4v4h-4zm0-16h4v12h-4zm1.99-10C12.94 4 4 12.95 4 24s8.94 20 19.99 20S44 35.05 44 24 35.04 4 23.99 4zM24 40c-8.84 0-16-7.16-16-16S15.16 8 24 8s16 7.16 16 16-7.16 16-16 16z" />
+      </svg>
+
+      <div class="title">{{ message }}</div>
+      <p v-if="statusCode === 404" class="description">
+        <a v-if="typeof $route === 'undefined'" class="error-link" href="/"></a>
+        <NuxtLink v-else class="error-link" to="/">Back to the home page</NuxtLink>
+      </p>
+
+      <div class="logo">
+        <a href="https://nuxtjs.org" target="_blank" rel="noopener">Nuxt</a>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script>
+export default {
+  name: 'NuxtError',
+  props: {
+    error: {
+      type: Object,
+      default: null
+    }
+  },
+  computed: {
+    statusCode () {
+      return (this.error && this.error.statusCode) || 500
+    },
+    message () {
+      return this.error.message || 'Error'
+    }
+  },
+  head () {
+    return {
+      title: this.message,
+      meta: [
+        {
+          name: 'viewport',
+          content: 'width=device-width,initial-scale=1.0,minimum-scale=1.0'
+        }
+      ]
+    }
+  }
+}
+</script>
+
+<style>
+.__nuxt-error-page {
+  padding: 1rem;
+  background: #F7F8FB;
+  color: #47494E;
+  text-align: center;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  flex-direction: column;
+  font-family: sans-serif;
+  font-weight: 100 !important;
+  -ms-text-size-adjust: 100%;
+  -webkit-text-size-adjust: 100%;
+  -webkit-font-smoothing: antialiased;
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+}
+.__nuxt-error-page .error {
+  max-width: 450px;
+}
+.__nuxt-error-page .title {
+  font-size: 1.5rem;
+  margin-top: 15px;
+  color: #47494E;
+  margin-bottom: 8px;
+}
+.__nuxt-error-page .description {
+  color: #7F828B;
+  line-height: 21px;
+  margin-bottom: 10px;
+}
+.__nuxt-error-page a {
+  color: #7F828B !important;
+  text-decoration: none;
+}
+.__nuxt-error-page .logo {
+  position: fixed;
+  left: 12px;
+  bottom: 12px;
+}
+</style>

.nuxt/components/nuxt-link.client.js

@@ -0,0 +1,98 @@
+import Vue from 'vue'
+
+const requestIdleCallback = window.requestIdleCallback ||
+  function (cb) {
+    const start = Date.now()
+    return setTimeout(function () {
+      cb({
+        didTimeout: false,
+        timeRemaining: () => Math.max(0, 50 - (Date.now() - start))
+      })
+    }, 1)
+  }
+
+const cancelIdleCallback = window.cancelIdleCallback || function (id) {
+  clearTimeout(id)
+}
+
+const observer = window.IntersectionObserver && new window.IntersectionObserver((entries) => {
+  entries.forEach(({ intersectionRatio, target: link }) => {
+    if (intersectionRatio <= 0 || !link.__prefetch) {
+      return
+    }
+    link.__prefetch()
+  })
+})
+
+export default {
+  name: 'NuxtLink',
+  extends: Vue.component('RouterLink'),
+  props: {
+    prefetch: {
+      type: Boolean,
+      default: true
+    },
+    noPrefetch: {
+      type: Boolean,
+      default: false
+    }
+  },
+  mounted () {
+    if (this.prefetch && !this.noPrefetch) {
+      this.handleId = requestIdleCallback(this.observe, { timeout: 2e3 })
+    }
+  },
+  beforeDestroy () {
+    cancelIdleCallback(this.handleId)
+
+    if (this.__observed) {
+      observer.unobserve(this.$el)
+      delete this.$el.__prefetch
+    }
+  },
+  methods: {
+    observe () {
+      // If no IntersectionObserver, avoid prefetching
+      if (!observer) {
+        return
+      }
+      // Add to observer
+      if (this.shouldPrefetch()) {
+        this.$el.__prefetch = this.prefetchLink.bind(this)
+        observer.observe(this.$el)
+        this.__observed = true
+      }
+    },
+    shouldPrefetch () {
+      return this.getPrefetchComponents().length > 0
+    },
+    canPrefetch () {
+      const conn = navigator.connection
+      const hasBadConnection = this.$nuxt.isOffline || (conn && ((conn.effectiveType || '').includes('2g') || conn.saveData))
+
+      return !hasBadConnection
+    },
+    getPrefetchComponents () {
+      const ref = this.$router.resolve(this.to, this.$route, this.append)
+      const Components = ref.resolved.matched.map(r => r.components.default)
+
+      return Components.filter(Component => typeof Component === 'function' && !Component.options && !Component.__prefetched)
+    },
+    prefetchLink () {
+      if (!this.canPrefetch()) {
+        return
+      }
+      // Stop observing this link (in case of internet connection changes)
+      observer.unobserve(this.$el)
+      const Components = this.getPrefetchComponents()
+
+      for (const Component of Components) {
+        const componentOrPromise = Component()
+        if (componentOrPromise instanceof Promise) {
+          componentOrPromise.catch(() => {})
+        }
+        Component.__prefetched = true
+      }
+    }
+  }
+}

.nuxt/components/nuxt-link.server.js

@@ -0,0 +1,16 @@
+import Vue from 'vue'
+
+export default {
+  name: 'NuxtLink',
+  extends: Vue.component('RouterLink'),
+  props: {
+    prefetch: {
+      type: Boolean,
+      default: true
+    },
+    noPrefetch: {
+      type: Boolean,
+      default: false
+    }
+  }
+}

.nuxt/components/nuxt.js

@@ -0,0 +1,101 @@
+import Vue from 'vue'
+import { compile } from '../utils'
+
+import NuxtError from '../../layouts/error.vue'
+
+import NuxtChild from './nuxt-child'
+
+export default {
+  name: 'Nuxt',
+  components: {
+    NuxtChild,
+    NuxtError
+  },
+  props: {
+    nuxtChildKey: {
+      type: String,
+      default: undefined
+    },
+    keepAlive: Boolean,
+    keepAliveProps: {
+      type: Object,
+      default: undefined
+    },
+    name: {
+      type: String,
+      default: 'default'
+    }
+  },
+  errorCaptured (error) {
+    // if we receive and error while showing the NuxtError component
+    // capture the error and force an immediate update so we re-render
+    // without the NuxtError component
+    if (this.displayingNuxtError) {
+      this.errorFromNuxtError = error
+      this.$forceUpdate()
+    }
+  },
+  computed: {
+    routerViewKey () {
+      // If nuxtChildKey prop is given or current route has children
+      if (typeof this.nuxtChildKey !== 'undefined' || this.$route.matched.length > 1) {
+        return this.nuxtChildKey || compile(this.$route.matched[0].path)(this.$route.params)
+      }
+
+      const [matchedRoute] = this.$route.matched
+
+      if (!matchedRoute) {
+        return this.$route.path
+      }
+
+      const Component = matchedRoute.components.default
+
+      if (Component && Component.options) {
+        const { options } = Component
+
+        if (options.key) {
+          return (typeof options.key === 'function' ? options.key(this.$route) : options.key)
+        }
+      }
+
+      const strict = /\/$/.test(matchedRoute.path)
+      return strict ? this.$route.path : this.$route.path.replace(/\/$/, '')
+    }
+  },
+  beforeCreate () {
+    Vue.util.defineReactive(this, 'nuxt', this.$root.$options.nuxt)
+  },
+  render (h) {
+    // if there is no error
+    if (!this.nuxt.err) {
+      // Directly return nuxt child
+      return h('NuxtChild', {
+        key: this.routerViewKey,
+        props: this.$props
+      })
+    }
+
+    // if an error occurred within NuxtError show a simple
+    // error message instead to prevent looping
+    if (this.errorFromNuxtError) {
+      this.$nextTick(() => (this.errorFromNuxtError = false))
+
+      return h('div', {}, [
+        h('h2', 'An error occurred while showing the error page'),
+        h('p', 'Unfortunately an error occurred and while showing the error page another error occurred'),
+        h('p', `Error details: ${this.errorFromNuxtError.toString()}`),
+        h('nuxt-link', { props: { to: '/' } }, 'Go back to home')
+      ])
+    }
+
+    // track if we are showing the NuxtError component
+    this.displayingNuxtError = true
+    this.$nextTick(() => (this.displayingNuxtError = false))
+
+    return h(NuxtError, {
+      props: {
+        error: this.nuxt.err
+      }
+    })
+  }
+}

.nuxt/components/plugin.js

@@ -0,0 +1,7 @@
+import Vue from 'vue'
+import * as components from './index'
+
+for (const name in components) {
+  Vue.component(name, components[name])
+  Vue.component('Lazy' + name, components[name])
+}

.nuxt/components/readme.md

@@ -0,0 +1,66 @@
+# Discovered Components
+
+This is an auto-generated list of components discovered by [nuxt/components](https://github.com/nuxt/components).
+
+You can directly use them in pages and other components without the need to import them.
+
+**Tip:** If a component is conditionally rendered with `v-if` and is big, it is better to use `Lazy` or `lazy-` prefix to lazy load.
+
+- `<Breadcrumb>` | `<breadcrumb>` (components/Breadcrumb.vue)
+- `<Bxh>` | `<bxh>` (components/Bxh.vue)
+- `<Card>` | `<card>` (components/Card.vue)
+- `<Carousel>` | `<carousel>` (components/Carousel.vue)
+- `<CategoryFilter>` | `<category-filter>` (components/CategoryFilter.vue)
+- `<CategoryNoData>` | `<category-no-data>` (components/CategoryNoData.vue)
+- `<DIalogXXSuccess>` | `<d-ialog-x-x-success>` (components/DIalogXXSuccess.vue)
+- `<DesignFormDialog>` | `<design-form-dialog>` (components/DesignFormDialog.vue)
+- `<DownloadDialog>` | `<download-dialog>` (components/DownloadDialog.vue)
+- `<ExportDialog>` | `<export-dialog>` (components/ExportDialog.vue)
+- `<FormDialog>` | `<form-dialog>` (components/FormDialog.vue)
+- `<ImageUpload>` | `<image-upload>` (components/ImageUpload.vue)
+- `<Pagination>` | `<pagination>` (components/Pagination.vue)
+- `<PcArticle>` | `<pc-article>` (components/PcArticle.vue)
+- `<PcFooter>` | `<pc-footer>` (components/PcFooter.vue)
+- `<PcGlobalForm>` | `<pc-global-form>` (components/PcGlobalForm.vue)
+- `<PcHeader>` | `<pc-header>` (components/PcHeader.vue)
+- `<PcHeaderLite>` | `<pc-header-lite>` (components/PcHeaderLite.vue)
+- `<PcSwitch>` | `<pc-switch>` (components/PcSwitch.vue)
+- `<PcTitle>` | `<pc-title>` (components/PcTitle.vue)
+- `<PdfHtml>` | `<pdf-html>` (components/PdfHtml.vue)
+- `<PriceToImg>` | `<price-to-img>` (components/PriceToImg.vue)
+- `<Project>` | `<project>` (components/Project.vue)
+- `<ProjectDialog>` | `<project-dialog>` (components/ProjectDialog.vue)
+- `<ResetPasswordMail>` | `<reset-password-mail>` (components/ResetPasswordMail.vue)
+- `<RowCard>` | `<row-card>` (components/RowCard.vue)
+- `<SubNav>` | `<sub-nav>` (components/SubNav.vue)
+- `<Subscription>` | `<subscription>` (components/Subscription.vue)
+- `<TabNav>` | `<tab-nav>` (components/TabNav.vue)
+- `<Zoom>` | `<zoom>` (components/Zoom.vue)
+- `<AddAddressDialog>` | `<add-address-dialog>` (components/addAddressDialog.vue)
+- `<BookCard>` | `<book-card>` (components/bookCard.vue)
+- `<ImageList>` | `<image-list>` (components/imageList.vue)
+- `<LoginDialog>` | `<login-dialog>` (components/loginDialog.vue)
+- `<ResetPasswordDialog>` | `<reset-password-dialog>` (components/resetPasswordDialog.vue)
+- `<TinymceDynamicLoadScript>` | `<tinymce-dynamic-load-script>` (components/Tinymce/dynamicLoadScript.js)
+- `<Tinymce>` | `<tinymce>` (components/Tinymce/index.vue)
+- `<TinymcePlugins>` | `<tinymce-plugins>` (components/Tinymce/plugins.js)
+- `<TinymceToolbar>` | `<tinymce-toolbar>` (components/Tinymce/toolbar.js)
+- `<ProductLeft>` | `<product-left>` (components/product/ProductLeft.vue)
+- `<ProductRight>` | `<product-right>` (components/product/ProductRight.vue)
+- `<ProductQuote>` | `<product-quote>` (components/product/Quote.vue)
+- `<CustomElSliderButton>` | `<custom-el-slider-button>` (components/custom-el-slider/button.vue)
+- `<CustomElSlider>` | `<custom-el-slider>` (components/custom-el-slider/index.vue)
+- `<CustomElSliderMarker>` | `<custom-el-slider-marker>` (components/custom-el-slider/marker.vue)
+- `<ProductBuilderDialogSelectAddr>` | `<product-builder-dialog-select-addr>` (components/product-builder/DialogSelectAddr.vue)
+- `<ProductBuilderStep1>` | `<product-builder-step1>` (components/product-builder/step-1.vue)
+- `<ProductBuilderStep2>` | `<product-builder-step2>` (components/product-builder/step-2.vue)
+- `<ProductBuilderStep3>` | `<product-builder-step3>` (components/product-builder/step-3.vue)
+- `<ProductBuilderStepMixin>` | `<product-builder-step-mixin>` (components/product-builder/stepMixin.vue)
+- `<TableChangeTable>` | `<table-change-table>` (components/table/ChangeTable.vue)
+- `<TableMailTable>` | `<table-mail-table>` (components/table/MailTable.vue)
+- `<TableNewPriceTable>` | `<table-new-price-table>` (components/table/NewPriceTable.vue)
+- `<TableStockTable>` | `<table-stock-table>` (components/table/StockTable.vue)
+- `<TableTotalTable>` | `<table-total-table>` (components/table/TotalTable.vue)
+- `<TableUnitTable>` | `<table-unit-table>` (components/table/UnitTable.vue)
+- `<TableParamTable>` | `<table-param-table>` (components/table/paramTable.vue)
+- `<TinymceComponentsEditorImage>` | `<tinymce-components-editor-image>` (components/Tinymce/components/EditorImage.vue)

.nuxt/cookie-universal-nuxt.js

@@ -0,0 +1,9 @@
+import cookieUniversal from 'cookie-universal'
+
+export default ({ req, res }, inject) => {
+  const options = {
+  "alias": "cookies",
+  "parseJSON": true
+}
+  inject(options.alias, cookieUniversal(req, res, options.parseJSON))
+}

.nuxt/dist/client/0451934.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[93],{668:function(t,e,n){t.exports={}},787:function(t,e,n){"use strict";n(668)},845:function(t,e,n){"use strict";n.r(e);var r=n(12),o=(n(57),{data:function(){return{refundInfo:""}},created:function(){var t=this;return Object(r.a)(regeneratorRuntime.mark((function e(){return regeneratorRuntime.wrap((function(e){for(;;)switch(e.prev=e.next){case 0:return e.next=2,t.getInfoList();case 2:case"end":return e.stop()}}),e)})))()},methods:{getInfoList:function(){var t=this;this.$axios.get("others/au/refund").then((function(e){1==e.code&&(t.refundInfo=e.result.content)}))}}}),c=(n(787),n(20)),component=Object(c.a)(o,(function(){var t=this,e=t._self._c;return e("div",{staticClass:"com-main com-width-1400 com-margin-auto"},[e("el-breadcrumb",{attrs:{"separator-class":"el-icon-arrow-right"}},[e("el-breadcrumb-item",{attrs:{to:{path:"/"}}},[t._v("Home")]),t._v(" "),e("el-breadcrumb-item",[t._v("Refund & Returns")])],1),t._v(" "),e("p",{staticClass:"title"},[t._v("Refund & Returns")]),t._v(" "),e("div",{staticClass:"line"}),t._v(" "),e("div",{staticClass:"item",domProps:{innerHTML:t._s(t.refundInfo)}})],1)}),[],!1,null,"12bc81a6",null);e.default=component.exports}}]);
+//# sourceMappingURL=0451934.js.map

.nuxt/dist/client/0e5a96c.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[94],{669:function(t,n,e){t.exports={}},788:function(t,n,e){"use strict";e(669)},846:function(t,n,e){"use strict";e.r(n);var r=e(12),o=(e(57),{data:function(){return{termsConditionsInfo:""}},fetch:function(){var t=this;return Object(r.a)(regeneratorRuntime.mark((function n(){return regeneratorRuntime.wrap((function(n){for(;;)switch(n.prev=n.next){case 0:return n.next=2,t.$store.dispatch("getShopInfo").then((function(n){t.termsConditionsInfo=n.terms}));case 2:case"end":return n.stop()}}),n)})))()},methods:{}}),c=(e(788),e(20)),component=Object(c.a)(o,(function(){var t=this,n=t._self._c;return n("div",{staticClass:"com-main com-width-1400 com-margin-auto"},[n("el-breadcrumb",{attrs:{"separator-class":"el-icon-arrow-right"}},[n("el-breadcrumb-item",{attrs:{to:{path:"/"}}},[t._v("Home")]),t._v(" "),n("el-breadcrumb-item",[t._v("Terms & Conditions")])],1),t._v(" "),n("p",{staticClass:"title"},[t._v("Terms & Conditions")]),t._v(" "),n("div",{staticClass:"line"}),t._v(" "),n("div",{staticClass:"item",domProps:{innerHTML:t._s(t.termsConditionsInfo)}})],1)}),[],!1,null,"7cc104a8",null);n.default=component.exports}}]);
+//# sourceMappingURL=0e5a96c.js.map

.nuxt/dist/client/0fb51f5.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[65],{526:function(e,t,o){"use strict";o.r(t);t.default=["advlist  autolink autosave code  colorpicker colorpicker contextmenu directionality  fullscreen hr insertdatetime link lists  nonbreaking noneditable paste preview print save  spellchecker tabfocus table template textcolor textpattern visualblocks visualchars wordcount"]}}]);
+//# sourceMappingURL=0fb51f5.js.map

.nuxt/dist/client/0fb51f5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["webpack:///./components/Tinymce/plugins.js"],"names":["plugins"],"mappings":"2FAAA,OAMeA,UAFC,CAAC,gR","file":"0fb51f5.js","sourcesContent":["// Any plugins you want to use has to be imported\n// Detail plugins list see https://www.tinymce.com/docs/plugins/\n// Custom builds see https://www.tinymce.com/download/custom-builds/\n\nconst plugins = ['advlist  autolink autosave code  colorpicker colorpicker contextmenu directionality  fullscreen hr insertdatetime link lists  nonbreaking noneditable paste preview print save  spellchecker tabfocus table template textcolor textpattern visualblocks visualchars wordcount']\n//anchor codesample emoticons pagebreak searchreplace image  imagetools media\nexport default plugins\n"],"sourceRoot":""}

.nuxt/dist/client/292e308.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[61],{588:function(t,e,l){t.exports={}},634:function(t,e,l){"use strict";l(588)},711:function(t,e,l){"use strict";l.r(e);var r={props:{tableData:{type:Array,default:[]},tableColumns:{type:Array,default:[]},operateWith:{type:String,default:"100%"},selectionShow:{type:Boolean,default:!1},handleShow:{type:Boolean,default:!1}},methods:{saveUnitData:function(t,e){this.tableData[e]=t,localStorage.setItem("unit",JSON.stringify(this.tableData))}}},o=(l(634),l(20)),component=Object(o.a)(r,(function(){var t=this,e=t._self._c;return e("div",[e("p",{staticClass:"tb-title"},[t._v("Markup %")]),t._v(" "),e("el-table",{ref:"elTable",style:{width:t.operateWith},attrs:{border:"",data:t.tableData,"highlight-current-row":!1,"header-cell-style":{backgroundColor:"#fff",color:"#606266",fontWeight:500,fontSize:"16px"}}},[t._l(t.tableColumns,(function(l){return[l.isText?e("el-table-column",{key:l.prop,attrs:{align:"center",prop:l.prop,label:l.label,formatter:l.formatter,width:l.width,sortable:l.sortable}}):t._e(),t._v(" "),l.isText?t._e():e("el-table-column",{key:l.prop,attrs:{prop:l.prop,label:l.label,formatter:l.formatter,width:l.width,align:l.align?l.align:"center",sortable:l.sortable},scopedSlots:t._u([{key:"default",fn:function(r){var o=r.row,n=r.$index;return[e("el-input",{staticClass:"edit-input",attrs:{size:"small",type:"number",min:"0"},on:{input:function(e){return t.saveUnitData(o,n)}},model:{value:o[l.prop],callback:function(e){t.$set(o,l.prop,e)},expression:"row[item.prop]"}})]}}],null,!0)})]}))],2)],1)}),[],!1,null,"931e8840",null);e.default=component.exports}}]);
+//# sourceMappingURL=292e308.js.map

.nuxt/dist/client/2f77874.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[51],{511:function(t,n,r){"use strict";var e=r(2),c=r(513);e({target:"String",proto:!0,forced:r(514)("link")},{link:function(t){return c(this,"a","href",t)}})},513:function(t,n,r){var e=r(4),c=r(32),o=r(13),f=/"/g,l=e("".replace);t.exports=function(t,n,r,e){var d=o(c(t)),v="<"+n;return""!==r&&(v+=" "+r+'="'+l(o(e),f,"&quot;")+'"'),v+">"+d+"</"+n+">"}},514:function(t,n,r){var e=r(5);t.exports=function(t){return e((function(){var n=""[t]('"');return n!==n.toLowerCase()||n.split('"').length>3}))}},598:function(t,n,r){t.exports={}},640:function(t,n,r){"use strict";r(598)},717:function(t,n,r){"use strict";r.r(n);r(511),r(39),r(71),r(95);var e={props:{data:{}},filters:{setTime:function(t){var n=t.split(" ")[0].split("-");return"".concat(n[2],"-").concat(n[1],"-").concat(n[0])}}},c=(r(640),r(20)),component=Object(c.a)(e,(function(){var t=this,n=t._self._c;return n("a",{attrs:{href:t.data.link,target:"_target"}},[n("figure",{staticClass:"card"},[n("div",{staticClass:"img",style:{backgroundImage:"url("+t.data.image+")"}}),t._v(" "),n("figcaption",{staticClass:"card-title"},[t._v("\n      "+t._s(t.data.title)+"\n    ")]),t._v(" "),n("figcaption",{staticClass:"card-info"},[n("p",[t._v(t._s(t._f("setTime")(t.data.update_time)))]),t._v(" "),n("p",[t._v(t._s(t.data.description))])])])])}),[],!1,null,"42187791",null);n.default=component.exports}}]);
+//# sourceMappingURL=2f77874.js.map

.nuxt/dist/client/2ff6fb6.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[29],{575:function(t,e,r){t.exports={}},617:function(t,e,r){"use strict";r(575)},701:function(t,e,r){"use strict";r.r(e);r(60);var n={components:{ElImageViewer:r(546).a},props:{data:{type:Array,default:function(){return[]}}},data:function(){return{currentPre:0,showViewer:!1}},computed:{comImg:function(){return this.data.map((function(i){return i.cdn_url}))}},methods:{scroll:function(t){var e=this.$refs.list;e.scrollLeft+=t*e.clientWidth},closeViewer:function(){this.showViewer=!1},handleViwer:function(i){this.currentPre=i,this.showViewer=!0}}},c=(r(617),r(20)),component=Object(c.a)(n,(function(){var t=this,e=t._self._c;return e("div",{staticClass:"wrap flex row"},[e("i",{staticClass:"el-icon-arrow-left",on:{click:function(e){return t.scroll(-1)}}}),t._v(" "),e("div",{ref:"list",staticClass:"list"},t._l(t.data,(function(r,n){return e("el-image",{key:n,staticClass:"image",attrs:{src:r.cdn_url,fit:"cover"},on:{click:function(e){return t.handleViwer(n)}}})})),1),t._v(" "),e("i",{staticClass:"el-icon-arrow-right",on:{click:function(e){return t.scroll(1)}}}),t._v(" "),t.showViewer?e("ElImageViewer",{attrs:{"initial-index":t.currentPre,"on-close":t.closeViewer,"url-list":t.comImg}}):t._e()],1)}),[],!1,null,"d262f43e",null);e.default=component.exports}}]);
+//# sourceMappingURL=2ff6fb6.js.map

.nuxt/dist/client/404d6d9.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[66],{527:function(e,r,o){"use strict";o.r(r);r.default=["searchreplace bold italic underline strikethrough alignleft aligncenter alignright outdent indent  blockquote undo redo removeformat subscript superscript code codesample","hr bullist numlist link image charmap preview anchor pagebreak insertdatetime media table emoticons forecolor backcolor fullscreen"]}}]);
+//# sourceMappingURL=404d6d9.js.map

.nuxt/dist/client/404d6d9.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["webpack:///./components/Tinymce/toolbar.js"],"names":["toolbar"],"mappings":"2FAAA,OAKeA,UAFC,CAAC,6KAA8K,qI","file":"404d6d9.js","sourcesContent":["// Here is a list of the toolbar\n// Detail list see https://www.tinymce.com/docs/advanced/editor-control-identifiers/#toolbarcontrols\n\nconst toolbar = ['searchreplace bold italic underline strikethrough alignleft aligncenter alignright outdent indent  blockquote undo redo removeformat subscript superscript code codesample', 'hr bullist numlist link image charmap preview anchor pagebreak insertdatetime media table emoticons forecolor backcolor fullscreen']\n\nexport default toolbar\n"],"sourceRoot":""}

.nuxt/dist/client/4313d10.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[26],{578:function(t,o,n){"use strict";var e=n(1);o.a=new e.default},688:function(t,o,n){t.exports={}},815:function(t,o,n){"use strict";n(688)},863:function(t,o,n){"use strict";n.r(o);var e=n(578),l={props:{visible:{type:Boolean,default:!1}},data:function(){return{downloading:!1}},mounted:function(){var t=this;e.a.$on("finishDownload",(function(data){t.downloading=!1}))},beforeDestroy:function(){e.a.$off("finishDownload")},methods:{handleDownload:function(){this.downloading=!0,e.a.$emit("sendDownload")},handleSend:function(){this.$emit("handleSend")},handleClose:function(){this.$emit("update:visible",!1)}}},d=(n(815),n(20)),component=Object(d.a)(l,(function(){var t=this,o=t._self._c;return o("el-dialog",{attrs:{"lock-scroll":!1,title:"Quote Created",visible:t.visible,width:"500px","before-close":t.handleClose,"show-close":!1,center:"",top:"0"},on:{"update:visible":function(o){t.visible=o}}},[o("div",{staticClass:"content"},[t._v("How would you like to receive the quote")]),t._v(" "),o("div",{staticClass:"dialog-footer",attrs:{slot:"footer"},slot:"footer"},[o("el-button",{attrs:{type:"danger",loading:t.downloading},on:{click:t.handleDownload}},[t._v("DOWNLOAD")]),t._v(" "),o("el-button",{attrs:{type:"danger"},on:{click:t.handleSend}},[t._v("SEND MAIL")]),t._v(" "),o("el-button",{attrs:{type:"danger",plain:""},on:{click:t.handleClose}},[t._v("CANCEL")])],1)])}),[],!1,null,"b2eaa3aa",null);o.default=component.exports}}]);
+//# sourceMappingURL=4313d10.js.map

.nuxt/dist/client/43e1a98.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[58],{569:function(t,e,r){t.exports={}},613:function(t,e,r){"use strict";r(569)},699:function(t,e,r){"use strict";r.r(e);r(39),r(71);var _={props:{data:{},colShow:{type:Boolean,default:!1}}},o=(r(613),r(20)),component=Object(o.a)(_,(function(){var t=this,e=t._self._c;return e("div",[e("table",[e("tbody",[e("tr",{staticClass:"title"},[e("th",{attrs:{width:"250px"}},[t._v("parameters")]),t._v(" "),e("th",{attrs:{width:"250px"}},[t._v("type")]),t._v(" "),t.colShow?e("th",{attrs:{width:"250px"}},[t._v("required")]):t._e(),t._v(" "),e("th",{attrs:{width:"250px"}},[t._v("description")])]),t._v(" "),t._l(t.data,(function(r,_){return e("tr",{key:_},[e("td",[t._v(t._s(r.parameters))]),t._v(" "),e("td",[t._v(t._s(r.type))]),t._v(" "),t.colShow?e("td",[t._v(t._s(r.required))]):t._e(),t._v(" "),e("td",[t._v(t._s(r.description))])])}))],2)])])}),[],!1,null,"bfc99702",null);e.default=component.exports}}]);
+//# sourceMappingURL=43e1a98.js.map

.nuxt/dist/client/5072b25.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[21],{556:function(t,e,r){"use strict";r.r(e);var o={name:"ComCategoryNoData",computed:{keyword:function(){var t=this.$route.query,e=this.$route.params;return t.keyword&&t.keyword.length?t.keyword:e.thirdCategory&&e.thirdCategory.length?e.thirdCategory:e.secondCategory&&e.secondCategory.length?e.secondCategory:e.firstCategory&&e.firstCategory.length?e.firstCategory:""}},methods:{toIndent:function(){var t=document.getElementById("indentLink");t&&t.click()}}},n=(r(612),r(20)),component=Object(n.a)(o,(function(){var t=this,e=t._self._c;return e("div",{staticClass:"com-category-no-data"},[e("div",{staticClass:"title"},[t._v('Search Results for"'+t._s(t.keyword)+'"')]),t._v(" "),e("div",{staticClass:"sub-title"},[t._v('\n    Sorry your search for "'+t._s(t.keyword)+'" returned no results.\n  ')]),t._v(" "),e("div",{staticClass:"content"},[t._v("\n    Your search term retured no results. You can use the search box above. If\n    you need further help,\n    "),e("br"),t._v(" "),e("span",{staticClass:"link",on:{click:t.toIndent}},[t._v("please fill in your requirements")]),t._v(", we will get in touch with you as soon as possible.\n  ")])])}),[],!1,null,"abeb0c0c",null);e.default=component.exports},568:function(t,e,r){t.exports={}},612:function(t,e,r){"use strict";r(568)}}]);
+//# sourceMappingURL=5072b25.js.map

.nuxt/dist/client/514ded2.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[52],{511:function(n,t,e){"use strict";var r=e(2),o=e(513);r({target:"String",proto:!0,forced:e(514)("link")},{link:function(n){return o(this,"a","href",n)}})},513:function(n,t,e){var r=e(4),o=e(32),c=e(13),l=/"/g,d=r("".replace);n.exports=function(n,t,e,r){var f=c(o(n)),m="<"+t;return""!==e&&(m+=" "+e+'="'+d(c(r),l,"&quot;")+'"'),m+">"+f+"</"+t+">"}},514:function(n,t,e){var r=e(5);n.exports=function(n){return r((function(){var t=""[n]('"');return t!==t.toLowerCase()||t.split('"').length>3}))}},597:function(n,t,e){n.exports={}},639:function(n,t,e){"use strict";e(597)},716:function(n,t,e){"use strict";e.r(t);e(511),e(61);var r={props:{secondaryBanner:[]},data:function(){return{imageLoaded:!1}},computed:{com_secondaryBanner:function(){return this.secondaryBanner.slice(0,4)},com_secondaryBannerLth:function(){var n;return null===(n=this.com_secondaryBanner)||void 0===n?void 0:n.length}}},o=(e(639),e(20)),component=Object(o.a)(r,(function(){var n=this,t=n._self._c;return t("section",{staticClass:"com-margin-auto sub-nav",style:{"max-width":"".concat(350*n.com_secondaryBannerLth,"px"),"grid-template-columns":"repeat(".concat(n.com_secondaryBannerLth,", 1fr)")}},n._l(n.com_secondaryBanner,(function(e){return t("figure",{key:e.id},[t("a",{attrs:{href:e.link,target:"_blank"}},[t("el-image",{staticStyle:{width:"100%"},style:{height:n.imageLoaded?"100%":"268px"},attrs:{lazy:"",src:e.image,alt:e.title,fit:"cover"},on:{load:function(t){n.imageLoaded=!0}}})],1)])})),0)}),[],!1,null,"caaef568",null);t.default=component.exports}}]);
+//# sourceMappingURL=514ded2.js.map

.nuxt/dist/client/534db3a.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[36,43],{509:function(t,r,e){"use strict";var n=e(2),o=e(25),c=e(11),f=e(7),path=e(311),l=e(4),N=e(147),I=e(15),v=e(309),E=e(56),_=e(113),h=e(310),m=e(5),T=e(112).f,w=e(51).f,d=e(27).f,y=e(510),A=e(312).trim,S="Number",F=f[S],x=path[S],O=F.prototype,k=f.TypeError,M=l("".slice),V=l("".charCodeAt),C=function(t){var r,e,n,o,c,f,l,code,N=h(t,"number");if(_(N))throw k("Cannot convert a Symbol value to a number");if("string"==typeof N&&N.length>2)if(N=A(N),43===(r=V(N,0))||45===r){if(88===(e=V(N,2))||120===e)return NaN}else if(48===r){switch(V(N,1)){case 66:case 98:n=2,o=49;break;case 79:case 111:n=8,o=55;break;default:return+N}for(f=(c=M(N,2)).length,l=0;l<f;l++)if((code=V(c,l))<48||code>o)return NaN;return parseInt(c,n)}return+N},G=N(S,!F(" 0o1")||!F("0b1")||F("+0x1")),L=function(t){var r,e=arguments.length<1?0:F(function(t){var r=h(t,"number");return"bigint"==typeof r?r:C(r)}(t));return E(O,r=this)&&m((function(){y(r)}))?v(Object(e),this,L):e};L.prototype=O,G&&!o&&(O.constructor=L),n({global:!0,constructor:!0,wrap:!0,forced:G},{Number:L});var j=function(t,source){for(var r,e=c?T(source):"MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,EPSILON,MAX_SAFE_INTEGER,MIN_SAFE_INTEGER,isFinite,isInteger,isNaN,isSafeInteger,parseFloat,parseInt,fromString,range".split(","),n=0;e.length>n;n++)I(source,r=e[n])&&!I(t,r)&&d(t,r,w(source,r))};o&&x&&j(path[S],x),(G||o)&&j(path[S],F)},510:function(t,r,e){var n=e(4);t.exports=n(1..valueOf)},530:function(t,r,e){t.exports={}},551:function(t,r,e){"use strict";e(530)},557:function(t,r,e){"use strict";e.r(r);e(509);var n={props:{title:String,marginTop:{type:Number}}},o=(e(551),e(20)),component=Object(o.a)(n,(function(){var t=this,r=t._self._c;return r("section",[r("h1",{style:{marginTop:t.marginTop+"px"}},[t._v("\n    "+t._s(t.title)+"\n  ")]),t._v(" "),r("span",{staticClass:"decoration"})])}),[],!1,null,"8446d0ce",null);r.default=component.exports}}]);
+//# sourceMappingURL=534db3a.js.map

.nuxt/dist/client/546715a.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[83],{835:function(n,t,e){"use strict";e.r(t);var r=e(12),o=(e(57),{data:function(){return{info:""}},fetch:function(){var n=this;return Object(r.a)(regeneratorRuntime.mark((function t(){return regeneratorRuntime.wrap((function(t){for(;;)switch(t.prev=t.next){case 0:return t.next=2,n.$store.dispatch("getShopInfo").then((function(t){n.info=t.contactus}));case 2:case"end":return t.stop()}}),t)})))()}}),c=e(20),component=Object(c.a)(o,(function(){var n=this,t=n._self._c;return t("div",{staticClass:"com-main com-width-1400 com-margin-auto"},[t("div",{staticClass:"content",domProps:{innerHTML:n._s(n.info)}}),n._v(" "),t("div")])}),[],!1,null,null,null);t.default=component.exports}}]);
+//# sourceMappingURL=546715a.js.map

.nuxt/dist/client/5959819.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[91,33],{573:function(t,e,r){t.exports={}},616:function(t,e,r){"use strict";r(573)},666:function(t,e,r){t.exports={}},700:function(t,e,r){"use strict";r.r(e);var n={props:{title:String,text:String}},c=(r(616),r(20)),component=Object(c.a)(n,(function(){var t=this,e=t._self._c;return e("div",[e("p",{staticClass:"title"},[t._v(t._s(t.title))]),t._v(" "),e("div",{staticClass:"line"}),t._v(" "),e("div",{staticClass:"item",domProps:{innerHTML:t._s(t.text)}})])}),[],!1,null,"89d0db98",null);e.default=component.exports},779:function(t,e,r){"use strict";r(666)},843:function(t,e,r){"use strict";r.r(e);var n=r(12),c=(r(57),{data:function(){return{privacyInfo:""}},created:function(){var t=this;return Object(n.a)(regeneratorRuntime.mark((function e(){return regeneratorRuntime.wrap((function(e){for(;;)switch(e.prev=e.next){case 0:return e.next=2,t.getInfoList();case 2:case"end":return e.stop()}}),e)})))()},methods:{getInfoList:function(){var t=this;this.$axios.get("others/privacy").then((function(e){1==e.code&&(t.privacyInfo=e.result.content)}))}}}),o=(r(779),r(20)),component=Object(o.a)(c,(function(){var t=this,e=t._self._c;return e("div",{staticClass:"com-main com-width-1400 com-margin-auto"},[e("el-breadcrumb",{attrs:{"separator-class":"el-icon-arrow-right"}},[e("el-breadcrumb-item",{attrs:{to:{path:"/"}}},[t._v("Home")]),t._v(" "),e("el-breadcrumb-item",[t._v("Privacy Policy")])],1),t._v(" "),e("pc-article",{attrs:{title:"Privacy Policy",text:t.privacyInfo}})],1)}),[],!1,null,"0110c098",null);e.default=component.exports;installComponents(component,{PcArticle:r(700).default})}}]);
+//# sourceMappingURL=5959819.js.map