text: module.exports =
  /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = require('../ssr-module-cache.js');
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		var threw = true;
  /******/ 		try {
  /******/ 			modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/ 			threw = false;
  /******/ 		} finally {
  /******/ 			if(threw) delete installedModules[moduleId];
  /******/ 		}
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// define __esModule on exports
  /******/ 	__webpack_require__.r = function(exports) {
  /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 		}
  /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 	};
  /******/
  /******/ 	// create a fake namespace object
  /******/ 	// mode & 1: value is a module id, require it
  /******/ 	// mode & 2: merge all properties of value into the ns
  /******/ 	// mode & 4: return value when already ns object
  /******/ 	// mode & 8|1: behave like require
  /******/ 	__webpack_require__.t = function(value, mode) {
  /******/ 		if(mode & 1) value = __webpack_require__(value);
  /******/ 		if(mode & 8) return value;
  /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 		var ns = Object.create(null);
  /******/ 		__webpack_require__.r(ns);
  /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 		return ns;
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 3);
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ "/jkW":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.__esModule = true;
  exports.isDynamicRoute = isDynamicRoute; // Identify /[param]/ in route string
  
  const TEST_ROUTE = /\/\[[^/]+?\](?=\/|$)/;
  
  function isDynamicRoute(route) {
    return TEST_ROUTE.test(route);
  }
  
  /***/ }),
  
  /***/ "0Bsm":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var _interopRequireDefault = __webpack_require__("TqRt");
  
  exports.__esModule = true;
  exports.default = withRouter;
  
  var _react = _interopRequireDefault(__webpack_require__("cDcd"));
  
  var _router = __webpack_require__("nOHt");
  
  function withRouter(ComposedComponent) {
    function WithRouterWrapper(props) {
      return /*#__PURE__*/_react.default.createElement(ComposedComponent, Object.assign({
        router: (0, _router.useRouter)()
      }, props));
    }
  
    WithRouterWrapper.getInitialProps = ComposedComponent.getInitialProps // This is needed to allow checking for custom getInitialProps in _app
    ;
    WithRouterWrapper.origGetInitialProps = ComposedComponent.origGetInitialProps;
  
    if (false) {}
  
    return WithRouterWrapper;
  }
  
  /***/ }),
  
  /***/ "23aj":
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  // ESM COMPAT FLAG
  __webpack_require__.r(__webpack_exports__);
  
  // EXTERNAL MODULE: external "react"
  var external_react_ = __webpack_require__("cDcd");
  var external_react_default = /*#__PURE__*/__webpack_require__.n(external_react_);
  
  // EXTERNAL MODULE: external "jquery"
  var external_jquery_ = __webpack_require__("xeH2");
  var external_jquery_default = /*#__PURE__*/__webpack_require__.n(external_jquery_);
  
  // EXTERNAL MODULE: external "mobx-react"
  var external_mobx_react_ = __webpack_require__("sGQ9");
  
  // EXTERNAL MODULE: ./components/layout/header.tsx
  var header = __webpack_require__("EFwJ");
  
  // CONCATENATED MODULE: ./components/modal.tsx
  var __jsx = external_react_default.a.createElement;
  
  
  
  class modal_Modal extends external_react_default.a.Component {
    static active() {
      external_jquery_default()('.modal, .modal-dialog').show();
    }
  
    static deactive() {
      external_jquery_default()('.modal, .modal-dialog').hide();
    }
  
    componentDidMount() {
      external_jquery_default()('.modal-close').click(() => {
        {
          modal_Modal.deactive();
        }
        ;
      });
      external_jquery_default()('.modal').click(event => {
        if (event.target.className == 'modal') {
          {
            modal_Modal.deactive();
          }
          ;
        }
      });
    }
  
    render() {
      return __jsx("div", {
        className: "modal"
      }, __jsx("div", {
        className: "modal-dialog"
      }, __jsx("div", {
        className: "modal-header"
      }, __jsx("div", {
        className: "modal-close"
      }, __jsx("img", {
        src: "/static/img/close_btn_01.svg"
      }))), __jsx("div", {
        className: "modal-content"
      }, this.props.children)));
    }
  
  }
  
  /* harmony default export */ var modal = (modal_Modal);
  // EXTERNAL MODULE: ./components/pages/title.tsx
  var title = __webpack_require__("OU1g");
  
  // EXTERNAL MODULE: ./components/pages/logo.tsx
  var logo = __webpack_require__("DywW");
  
  // EXTERNAL MODULE: ./node_modules/next/link.js
  var next_link = __webpack_require__("YFqc");
  var link_default = /*#__PURE__*/__webpack_require__.n(next_link);
  
  // EXTERNAL MODULE: external "moment"
  var external_moment_ = __webpack_require__("wy2R");
  var external_moment_default = /*#__PURE__*/__webpack_require__.n(external_moment_);
  
  // EXTERNAL MODULE: ./lib/common.tsx
  var common = __webpack_require__("Y25M");
  
  // CONCATENATED MODULE: ./components/pages/tab.tsx
  var tab_jsx = external_react_default.a.createElement;
  
  
  
  
  
  
  class tab_Tab extends external_react_default.a.Component {
    runSpin() {
      const target = external_jquery_default()('#tab > ul > li:last-child > img:last-child');
      target.removeClass('spin');
      setTimeout(() => {
        target.addClass('spin');
      }, 1);
    }
  
    refresh() {
      common["a" /* Interval */].clearAll();
      this.runSpin();
      this.props.handler();
    }
  
    render() {
      return tab_jsx("div", {
        className: "content bg-c-yellow tab"
      }, tab_jsx("div", {
        className: "inner-content"
      }, tab_jsx("div", {
        id: "date"
      }, tab_jsx("p", null, external_moment_default()().format('YYYY/MM/DD'))), tab_jsx("div", {
        id: "tab"
      }, tab_jsx("ul", null, tab_jsx("li", null, tab_jsx(link_default.a, {
        href: "/"
      }, tab_jsx("a", {
        id: "tab-title"
      }, "Main")), tab_jsx("div", {
        id: "tab-title-bar"
      })), tab_jsx("li", null, tab_jsx(link_default.a, {
        href: "/settings"
      }, tab_jsx("img", {
        src: "/static/img/setting_btn_01.svg"
      })), tab_jsx("img", {
        src: "/static/img/refresh_btn_01.svg",
        onClick: this.refresh.bind(this)
      }))))));
    }
  
  }
  
  /* harmony default export */ var tab = (tab_Tab);
  // EXTERNAL MODULE: ./lib/bus.tsx
  var lib_bus = __webpack_require__("85Dp");
  
  // EXTERNAL MODULE: external "axios"
  var external_axios_ = __webpack_require__("zr5I");
  var external_axios_default = /*#__PURE__*/__webpack_require__.n(external_axios_);
  
  // EXTERNAL MODULE: ./config.json
  var config = __webpack_require__("81W9");
  
  // CONCATENATED MODULE: ./lib/weather.tsx
  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  
  
  
  
  
  
  class weather_WeatherAPI {
    constructor() {
      _defineProperty(this, "API_KEY", config.WEATHER_API_KEY);
    }
  
    getCurrentWeather(location = 'Seoul') {
      return external_axios_default.a.get(`http://api.openweathermap.org/data/2.5/weather?q=${location}&appid=${this.API_KEY}`).then(response => {
        const weather = new weather_Weather(response.data);
        return weather.getData();
      }).catch(error => {
        console.log(error);
        return {};
      });
    }
  
    getHourlyWeather() {
      return external_axios_default.a.get('http://api.openweathermap.org/data/2.5/forecast?q=Seoul&appid=' + this.API_KEY).then(response => {
        let list = [];
  
        for (const data of response.data.list) {
          const weather = new weather_Weather(data);
          list.push(weather.getData());
        }
  
        return list;
      }).catch(error => {
        console.log(error);
        return [];
      });
    }
  
  }
  
  class weather_Weather {
    constructor(data) {
      _defineProperty(this, "data", void 0);
  
      _defineProperty(this, "weather", void 0);
  
      _defineProperty(this, "main", void 0);
  
      this.data = data;
      this.weather = this.data.weather;
      this.main = this.data.main;
    }
  
    getWeather() {
      let data = {};
  
      for (const w of this.weather) {
        data.id = w.id;
        data.icon = 'http://openweathermap.org/img/wn/' + w.icon + '@2x.png';
        data.main = w.main;
        data.desc = w.description;
        break;
      }
  
      return data;
    }
  
    getTemp() {
      const t = new common["d" /* Temperature */]();
      const temp = t.kelvinToCelsius(this.main.temp);
      const minTemp = t.kelvinToCelsius(this.main.temp_min);
      const maxTemp = t.kelvinToCelsius(this.main.temp_max);
      return {
        temp,
        minTemp,
        maxTemp
      };
    }
  
    getDateTime() {
      return this.data.dt * 1000;
    }
  
    getData() {
      const weather = this.getWeather();
      const temp = this.getTemp();
      const dt = this.getDateTime();
      return external_jquery_default.a.extend(weather, temp, {
        dt
      });
    }
  
  }
  
  
  // EXTERNAL MODULE: ./lib/subway.tsx
  var subway = __webpack_require__("sH5C");
  
  // CONCATENATED MODULE: ./components/pages/list.tsx
  var list_jsx = external_react_default.a.createElement;
  
  function list_defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  
  
  
  
  
  
  
  
  
  
  class list_List extends external_react_default.a.Component {
    constructor(...args) {
      super(...args);
  
      list_defineProperty(this, "_ismounted", true);
  
      list_defineProperty(this, "state", {
        currentTime: '',
        currentWeather: list_jsx("div", null),
        buses: [],
        subways: []
      });
    }
  
    setCurrentTime() {
      const interval = new common["a" /* Interval */]();
      interval.set(() => {
        if (this._ismounted) {
          this.setState({
            currentTime: external_moment_default()().format('HH:mm:ss')
          });
        }
      }, 1000);
    }
  
    setCurrentWeather() {
      const weatherAPI = new weather_WeatherAPI();
      weatherAPI.getCurrentWeather().then(data => {
        if (this._ismounted) {
          this.setState({
            currentWeather: list_jsx("div", {
              id: "current_weather"
            }, list_jsx("div", {
              id: "current_weather_title",
              className: "list"
            }, list_jsx("div", null, list_jsx("img", {
              src: data.icon
            })), list_jsx("div", null, list_jsx("p", null, data.temp, "\xB0"))), list_jsx("p", {
              id: "current_weather_main"
            }, data.main), list_jsx("p", {
              id: "current_weather_desc"
            }, data.desc), list_jsx("div", {
              id: "current_weather_more"
            }, list_jsx("img", {
              src: "/static/img/plus_btn_01.svg",
              onClick: modal.active
            })))
          });
        }
      });
    }
  
    setCurrentBus() {
      const api = new lib_bus["a" /* BusAPI */]();
      api.getBuses(this.props.token).then(data => {
        let arr = [];
  
        for (let bus of data) {
          const key = `${bus.station_id}${bus.bus_route_id}`;
          arr.push(list_jsx("div", {
            className: "current_bus",
            key: key
          }, list_jsx("p", {
            className: "current_bus_title"
          }, bus.name), list_jsx("p", {
            className: "current_bus_message",
            id: key
          })));
        }
  
        this.setState({
          'buses': arr
        });
  
        for (let bus of data) {
          const key = `${bus.station_id}${bus.bus_route_id}`;
          const target = external_jquery_default()(`#${key}`);
          lib_bus["b" /* BusUI */].setCurrentBus(target, bus.station_id, bus.bus_route_id, bus.ord);
        }
      });
    }
  
    setCurrentSubway() {
      let subways = {};
      const api = new subway["a" /* SubwayAPI */]();
      api.getSubways(this.props.token).then(data => {
        let trainLineNameCnt = 0;
  
        for (let subway of data) {
          subways[subway.station_name] = {};
        }
  
        for (let subway of data) {
          if (subways[subway.station_name][subway.direction]) {
            subways[subway.station_name][subway.direction].push(subway.train_line_name);
          } else {
            subways[subway.station_name][subway.direction] = [subway.train_line_name];
          }
  
          trainLineNameCnt += 1;
        }
  
        let arr = [];
  
        for (let stationName in subways) {
          for (let direction in subways[stationName]) {
            for (let trainLineName of subways[stationName][direction]) {
              if (trainLineNameCnt > 2) {
                arr.push(list_jsx("div", {
                  key: trainLineName,
                  className: "current_subway"
                }, list_jsx("div", {
                  className: "current_subway_title"
                }, trainLineName), list_jsx("div", {
                  className: "current_subway_message",
                  id: trainLineName.replace(/\s/gi, "")
                })));
              } else {
                arr.push(list_jsx("div", {
                  key: trainLineName,
                  className: "current_subway_solo"
                }, list_jsx("div", {
                  className: "current_subway_solo_title"
                }, trainLineName), list_jsx("div", {
                  className: "current_subway_solo_message",
                  id: trainLineName.replace(/\s/gi, "")
                })));
              }
            }
          }
        }
  
        if (arr.length > 2) {
          this.setState({
            'subways': list_jsx("div", null, arr)
          });
        } else {
          this.setState({
            'subways': arr
          });
        }
  
        for (let stationName in subways) {
          for (let direction in subways[stationName]) {
            for (let trainLineName of subways[stationName][direction]) {
              const target = external_jquery_default()(`#${trainLineName.replace(/\s/gi, "")}`);
              subway["b" /* SubwayUI */].setCurrentSubway(target, stationName, trainLineName);
            }
          }
        }
      });
    }
  
    setAll() {
      this.setCurrentTime();
      this.setCurrentWeather();
      this.setCurrentBus();
      this.setCurrentSubway();
    }
  
    componentDidMount() {
      this._ismounted = true;
      this.setAll();
    }
  
    componentWillUnmount() {
      this._ismounted = false;
    }
  
    componentWillReceiveProps(nextProps) {
      if (nextProps.refresh == true) {
        this.setAll();
      }
    }
  
    render() {
      return list_jsx("div", {
        className: "content"
      }, list_jsx("div", {
        className: "inner-content",
        id: "list"
      }, list_jsx("div", {
        className: "list"
      }, list_jsx("div", null, list_jsx("p", {
        id: "current_time"
      }, this.state.currentTime)), list_jsx("div", null, this.state.currentWeather), this.state.buses, this.state.subways)));
    }
  
  }
  
  /* harmony default export */ var pages_list = (list_List);
  // EXTERNAL MODULE: ./components/pages/footer.tsx
  var footer = __webpack_require__("RnLg");
  
  // CONCATENATED MODULE: ./components/pages/hourlyWeather.tsx
  var hourlyWeather_jsx = external_react_default.a.createElement;
  
  function hourlyWeather_defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  
  
  
  
  
  class hourlyWeather_HourlyWeather extends external_react_default.a.Component {
    constructor(...args) {
      super(...args);
  
      hourlyWeather_defineProperty(this, "state", {
        hourlyWeather: []
      });
    }
  
    setHourlyWeather() {
      const weatherAPI = new weather_WeatherAPI();
      weatherAPI.getHourlyWeather().then(list => {
        let html = [];
  
        for (const data of list.slice(0, 10)) {
          html.push(hourlyWeather_jsx("div", {
            key: data.dt
          }, external_moment_default()(data.dt).format('HH:mm'), hourlyWeather_jsx("br", null), hourlyWeather_jsx("img", {
            src: data.icon
          }), hourlyWeather_jsx("br", null), data.temp, "\xB0", hourlyWeather_jsx("br", null), data.main, hourlyWeather_jsx("br", null)));
        }
  
        this.setState({
          hourlyWeather: html
        });
      });
    }
  
    componentDidMount() {
      this.setHourlyWeather();
    }
  
    componentWillReceiveProps(nextProps) {
      if (nextProps.refresh == true) {
        this.setHourlyWeather();
      }
    }
  
    render() {
      return hourlyWeather_jsx("div", {
        id: "hourly_weather"
      }, this.state.hourlyWeather);
    }
  
  }
  
  /* harmony default export */ var hourlyWeather = (hourlyWeather_HourlyWeather);
  // CONCATENATED MODULE: ./pages/index.tsx
  var _dec, _class, _temp;
  
  var pages_jsx = external_react_default.a.createElement;
  
  function pages_defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  
  
  
  
  
  
  
  
  
  
  
  
  let pages_IndexPage = (_dec = Object(external_mobx_react_["inject"])('store'), _dec(_class = Object(external_mobx_react_["observer"])(_class = (_temp = class IndexPage extends external_react_default.a.Component {
    constructor(...args) {
      super(...args);
  
      pages_defineProperty(this, "state", {
        refresh: false
      });
    }
  
    static getInitialProps(ctx) {
      return {
        token: ctx.query.token
      };
    }
  
    changeTabMode() {
      const height = external_jquery_default()('#title').height() + external_jquery_default()('#logo').height() + external_jquery_default()('.tab').height();
      external_jquery_default()(window).scroll(() => {
        const windowHeight = external_jquery_default()(document).scrollTop();
  
        if (windowHeight > height) {
          external_jquery_default()('.tab').removeClass('tab').addClass('mini-tab');
          external_jquery_default()('#list').css({
            'margin-top': '290px'
          });
        } else {
          external_jquery_default()('.mini-tab').removeClass('mini-tab').addClass('tab');
          external_jquery_default()('#list').css({
            'margin-top': '-50px'
          });
        }
      });
    }
  
    refresh() {
      this.setState({
        refresh: true
      });
    }
  
    componentDidMount() {
      this.changeTabMode();
    }
  
    render() {
      const token = this.props.token || this.props.store.token;
  
      if (token) {
        {
          this.props.store.signin(token);
        }
      }
  
      return pages_jsx("div", null, pages_jsx(header["a" /* default */], {
        title: "EASYWAY"
      }), pages_jsx(title["a" /* default */], {
        isSignin: this.props.store.isSignin
      }), pages_jsx(logo["a" /* default */], null), pages_jsx(tab, {
        handler: this.refresh.bind(this)
      }), pages_jsx(pages_list, {
        refresh: this.state.refresh,
        token: token
      }), pages_jsx(footer["a" /* default */], null), pages_jsx(modal, null, pages_jsx(hourlyWeather, {
        refresh: this.state.refresh
      })));
    }
  
  }, _temp)) || _class) || _class);
  /* harmony default export */ var pages = __webpack_exports__["default"] = (pages_IndexPage);
  
  /***/ }),
  
  /***/ "284h":
  /***/ (function(module, exports, __webpack_require__) {
  
  var _typeof = __webpack_require__("cDf5");
  
  function _getRequireWildcardCache() {
    if (typeof WeakMap !== "function") return null;
    var cache = new WeakMap();
  
    _getRequireWildcardCache = function _getRequireWildcardCache() {
      return cache;
    };
  
    return cache;
  }
  
  function _interopRequireWildcard(obj) {
    if (obj && obj.__esModule) {
      return obj;
    }
  
    if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
      return {
        "default": obj
      };
    }
  
    var cache = _getRequireWildcardCache();
  
    if (cache && cache.has(obj)) {
      return cache.get(obj);
    }
  
    var newObj = {};
    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
  
    for (var key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
  
        if (desc && (desc.get || desc.set)) {
          Object.defineProperty(newObj, key, desc);
        } else {
          newObj[key] = obj[key];
        }
      }
    }
  
    newObj["default"] = obj;
  
    if (cache) {
      cache.set(obj, newObj);
    }
  
    return newObj;
  }
  
  module.exports = _interopRequireWildcard;
  
  /***/ }),
  
  /***/ 3:
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = __webpack_require__("23aj");
  
  
  /***/ }),
  
  /***/ "3WeD":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.__esModule = true;
  exports.searchParamsToUrlQuery = searchParamsToUrlQuery;
  exports.urlQueryToSearchParams = urlQueryToSearchParams;
  exports.assign = assign;
  
  function searchParamsToUrlQuery(searchParams) {
    const query = {};
    searchParams.forEach((value, key) => {
      if (typeof query[key] === 'undefined') {
        query[key] = value;
      } else if (Array.isArray(query[key])) {
        ;
        query[key].push(value);
      } else {
        query[key] = [query[key], value];
      }
    });
    return query;
  }
  
  function urlQueryToSearchParams(urlQuery) {
    const result = new URLSearchParams();
    Object.entries(urlQuery).forEach(([key, value]) => {
      if (Array.isArray(value)) {
        value.forEach(item => result.append(key, item));
      } else {
        result.set(key, value);
      }
    });
    return result;
  }
  
  function assign(target, ...searchParamsList) {
    searchParamsList.forEach(searchParams => {
      Array.from(searchParams.keys()).forEach(key => target.delete(key));
      searchParams.forEach((value, key) => target.append(key, value));
    });
    return target;
  }
  
  /***/ }),
  
  /***/ "6D7l":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.__esModule = true;
  exports.formatUrl = formatUrl;
  
  var querystring = _interopRequireWildcard(__webpack_require__("3WeD"));
  
  function _getRequireWildcardCache() {
    if (typeof WeakMap !== "function") return null;
    var cache = new WeakMap();
  
    _getRequireWildcardCache = function () {
      return cache;
    };
  
    return cache;
  }
  
  function _interopRequireWildcard(obj) {
    if (obj && obj.__esModule) {
      return obj;
    }
  
    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
      return {
        default: obj
      };
    }
  
    var cache = _getRequireWildcardCache();
  
    if (cache && cache.has(obj)) {
      return cache.get(obj);
    }
  
    var newObj = {};
    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
  
    for (var key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
  
        if (desc && (desc.get || desc.set)) {
          Object.defineProperty(newObj, key, desc);
        } else {
          newObj[key] = obj[key];
        }
      }
    }
  
    newObj.default = obj;
  
    if (cache) {
      cache.set(obj, newObj);
    }
  
    return newObj;
  } // Format function modified from nodejs
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  
  const slashedProtocols = /https?|ftp|gopher|file/;
  
  function formatUrl(urlObj) {
    let {
      auth,
      hostname
    } = urlObj;
    let protocol = urlObj.protocol || '';
    let pathname = urlObj.pathname || '';
    let hash = urlObj.hash || '';
    let query = urlObj.query || '';
    let host = false;
    auth = auth ? encodeURIComponent(auth).replace(/%3A/i, ':') + '@' : '';
  
    if (urlObj.host) {
      host = auth + urlObj.host;
    } else if (hostname) {
      host = auth + (~hostname.indexOf(':') ? `[${hostname}]` : hostname);
  
      if (urlObj.port) {
        host += ':' + urlObj.port;
      }
    }
  
    if (query && typeof query === 'object') {
      query = String(querystring.urlQueryToSearchParams(query));
    }
  
    let search = urlObj.search || query && `?${query}` || '';
    if (protocol && protocol.substr(-1) !== ':') protocol += ':';
  
    if (urlObj.slashes || (!protocol || slashedProtocols.test(protocol)) && host !== false) {
      host = '//' + (host || '');
      if (pathname && pathname[0] !== '/') pathname = '/' + pathname;
    } else if (!host) {
      host = '';
    }
  
    if (hash && hash[0] !== '#') hash = '#' + hash;
    if (search && search[0] !== '?') search = '?' + search;
    pathname = pathname.replace(/[?#]/g, encodeURIComponent);
    search = search.replace('#', '%23');
    return `${protocol}${host}${pathname}${search}${hash}`;
  }
  
  /***/ }),
  
  /***/ "81W9":
  /***/ (function(module) {
  
  module.exports = JSON.parse("{\"SUBWAY_API_KEY\":\"576e7641637779753339776e735745\",\"WEATHER_API_KEY\":\"915caab145ec09ce7724d09944d89cb1\",\"BUS_API_KEY\":\"ldbaTdPATqmbFE3k5T1zUnG%2BeTKS57wNuX%2FuI6pWqlIxKRKEaF1gXzGx3Ex4sU6GGs%2BnCa%2BbAddYXbwpPSkZag%3D%3D\",\"KELVIN_NUM\":273.15,\"API_HOST\":\"http://apis.easyway.gureuso.me\",\"APP_MODE\":\"production\",\"APP_PORT\":3000,\"APP_HOST\":\"localhost\"}");
  
  /***/ }),
  
  /***/ "85Dp":
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return BusUI; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return BusAPI; });
  /* harmony import */ var axios__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("zr5I");
  /* harmony import */ var axios__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(axios__WEBPACK_IMPORTED_MODULE_0__);
  /* harmony import */ var fast_xml_parser__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("NS32");
  /* harmony import */ var fast_xml_parser__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(fast_xml_parser__WEBPACK_IMPORTED_MODULE_1__);
  /* harmony import */ var config_json__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("81W9");
  var config_json__WEBPACK_IMPORTED_MODULE_2___namespace = /*#__PURE__*/__webpack_require__.t("81W9", 1);
  /* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("Y25M");
  /* harmony import */ var _ui__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("Uh3f");
  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  
  
  
  
  
  
  
  class BusUI {
    static setWaitingTime(target, sec, stId, busRouteId, ord) {
      const ui = new _ui__WEBPACK_IMPORTED_MODULE_4__[/* TimeUI */ "a"]();
      ui.setWaitingTimeWithBus(target, sec, BusUI.setCurrentBus, stId, busRouteId, ord);
    }
  
    static setCurrentBus(target, stId, busRouteId, ord) {
      const api = new BusAPI();
      api.getDataByRoute(stId, busRouteId, ord).then(data => {
        if (data) {
          const bus = new Bus(data);
          const waitingSec = bus.getWaitingSec();
  
          if (waitingSec < 1) {
            target.text(bus.message);
          } else {
            BusUI.setWaitingTime(target, waitingSec, stId, busRouteId, ord);
          }
        } else {
          target.text('data is null');
        }
      });
    }
  
  }
  
  class BusAPI {
    constructor() {
      _defineProperty(this, "API_KEY", config_json__WEBPACK_IMPORTED_MODULE_2__.BUS_API_KEY);
  
      _defineProperty(this, "PROXY_HOST", config_json__WEBPACK_IMPORTED_MODULE_2__.API_HOST);
    }
  
    proxy(url) {
      return axios__WEBPACK_IMPORTED_MODULE_0___default.a.get(this.PROXY_HOST + '/apis/proxy?url=' + encodeURIComponent(url)).then(response => {
        const data = fast_xml_parser__WEBPACK_IMPORTED_MODULE_1___default.a.parse(response.data.data.data).ServiceResult.msgBody;
        return data ? data.itemList : undefined;
      }).catch(error => {
        console.log(error);
        return undefined;
      });
    }
  
    createBus(name, stationId, busRouteId, ord, token) {
      const form = new FormData();
      form.append('name', name);
      form.append('station_id', stationId);
      form.append('bus_route_id', busRouteId);
      form.append('ord', ord);
      form.append('token', token);
      return axios__WEBPACK_IMPORTED_MODULE_0___default.a.post(`${this.PROXY_HOST}/public_transport/buses/create`, form).then(response => {
        return response.data.data;
      }).catch(error => {
        console.log(error);
        return {};
      });
    }
  
    deleteBus(id, token) {
      return axios__WEBPACK_IMPORTED_MODULE_0___default.a.delete(`${this.PROXY_HOST}/public_transport/buses/${id}/delete?token=${token}`).then(response => {
        return response.data;
      }).catch(error => {
        console.log(error);
        return {};
      });
    }
  
    getBuses(token) {
      return axios__WEBPACK_IMPORTED_MODULE_0___default.a.get(`${this.PROXY_HOST}/public_transport/buses?token=${token}`).then(response => {
        return response.data.data.buses;
      }).catch(error => {
        console.log(error);
        return [];
      });
    }
  
    getBusRoute(arsId) {
      let url = 'http://ws.bus.go.kr/api/rest/stationinfo/getStationByUid?';
      url += 'serviceKey=' + this.API_KEY;
      url += '&arsId=' + arsId;
      return this.proxy(url);
    }
  
    getBusStation(name) {
      let url = 'http://ws.bus.go.kr/api/rest/stationinfo/getStationByName?';
      url += 'serviceKey=' + this.API_KEY;
      url += '&stSrch=' + name;
      return this.proxy(url);
    }
  
    getDataByRoute(stId, busRouteId, ord) {
      let url = 'http://ws.bus.go.kr/api/rest/arrive/getArrInfoByRoute?';
      url += 'serviceKey=' + this.API_KEY;
      url += '&stId=' + stId;
      url += '&busRouteId=' + busRouteId;
      url += '&ord=' + ord;
      return this.proxy(url);
    }
  
  }
  
  class BusMessage {
    constructor(message) {
      _defineProperty(this, "message", void 0);
  
      this.message = message;
    }
  
    getWaitingSec() {
      const matchMinute = this.message.match(/\d+분/g);
      const minute = matchMinute ? parseInt(matchMinute[0].replace('분', '')) : 0;
      const matchSec = this.message.match(/\d+초/g);
      const sec = matchSec ? parseInt(matchSec[0].replace('초', '')) : 0;
      return minute * 60 + sec;
    }
  
    checkBusShutdown() {
      if (this.message.search(/운행종료/g) != -1) {
        return true;
      } else {
        return false;
      }
    }
  
  }
  
  class Bus {
    constructor(data) {
      _defineProperty(this, "data", void 0);
  
      _defineProperty(this, "busNum", void 0);
  
      _defineProperty(this, "message", void 0);
  
      _defineProperty(this, "apiCallTime", void 0);
  
      this.data = data;
      this.busNum = parseInt(this.data.rtNm);
      this.message = this.data.arrmsg1;
      this.apiCallTime = this.data.mkTm;
    }
  
    getCorrectionSec() {
      const m = new _common__WEBPACK_IMPORTED_MODULE_3__[/* Moment */ "b"]();
      return m.getCorrectionSec(this.apiCallTime);
    }
  
    getWaitingSec() {
      const bm = new BusMessage(this.message);
      return bm.getWaitingSec() - this.getCorrectionSec();
    }
  
  }
  
  
  
  /***/ }),
  
  /***/ "DywW":
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("cDcd");
  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
  var __jsx = react__WEBPACK_IMPORTED_MODULE_0___default.a.createElement;
  
  
  class Logo extends react__WEBPACK_IMPORTED_MODULE_0___default.a.Component {
    render() {
      return __jsx("div", {
        className: "content",
        id: "logo"
      }, __jsx("img", {
        src: "/static/img/easyway_title.png"
      }));
    }
  
  }
  
  /* harmony default export */ __webpack_exports__["a"] = (Logo);
  
  /***/ }),
  
  /***/ "EFwJ":
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("cDcd");
  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
  /* harmony import */ var next_head__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("xnum");
  /* harmony import */ var next_head__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(next_head__WEBPACK_IMPORTED_MODULE_1__);
  var __jsx = react__WEBPACK_IMPORTED_MODULE_0___default.a.createElement;
  
  
  
  class Header extends react__WEBPACK_IMPORTED_MODULE_0___default.a.Component {
    render() {
      return __jsx(next_head__WEBPACK_IMPORTED_MODULE_1___default.a, null, __jsx("title", null, this.props.title));
    }
  
  }
  
  /* harmony default export */ __webpack_exports__["a"] = (Header);
  
  /***/ }),
  
  /***/ "NS32":
  /***/ (function(module, exports) {
  
  module.exports = require("fast-xml-parser");
  
  /***/ }),
  
  /***/ "OU1g":
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("cDcd");
  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
  /* harmony import */ var next_link__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("YFqc");
  /* harmony import */ var next_link__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(next_link__WEBPACK_IMPORTED_MODULE_1__);
  var __jsx = react__WEBPACK_IMPORTED_MODULE_0___default.a.createElement;
  
  
  
  class Title extends react__WEBPACK_IMPORTED_MODULE_0___default.a.Component {
    renderSignin() {
      if (this.props.isSignin) {
        return __jsx("div", {
          className: "content"
        }, __jsx("ul", {
          id: "signin"
        }, __jsx("li", null, __jsx(next_link__WEBPACK_IMPORTED_MODULE_1___default.a, {
          href: "/signout"
        }, __jsx("a", null, "\uB85C\uADF8\uC544\uC6C3")))));
      } else {
        return __jsx("div", {
          className: "content"
        }, __jsx("ul", {
          id: "signin"
        }, __jsx("li", null, __jsx(next_link__WEBPACK_IMPORTED_MODULE_1___default.a, {
          href: "/signin"
        }, __jsx("a", null, "\uB85C\uADF8\uC778")))));
      }
    }
  
    render() {
      return __jsx("div", null, this.renderSignin(), __jsx("div", {
        className: "content bg-c-gray",
        id: "title"
      }, __jsx("p", null, "\uAC71\uC815\uC5C6\uC774 \uC9D1\uC744 \uB098\uAC00\uC790!"), __jsx("h1", null, __jsx(next_link__WEBPACK_IMPORTED_MODULE_1___default.a, {
        href: "/"
      }, __jsx("a", null, "EASYWAY")))));
    }
  
  }
  
  /* harmony default export */ __webpack_exports__["a"] = (Title);
  
  /***/ }),
  
  /***/ "Osoz":
  /***/ (function(module, exports) {
  
  module.exports = require("next/dist/next-server/lib/router-context.js");
  
  /***/ }),
  
  /***/ "RnLg":
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("cDcd");
  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
  /* harmony import */ var next_link__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("YFqc");
  /* harmony import */ var next_link__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(next_link__WEBPACK_IMPORTED_MODULE_1__);
  var __jsx = react__WEBPACK_IMPORTED_MODULE_0___default.a.createElement;
  
  
  
  class Footer extends react__WEBPACK_IMPORTED_MODULE_0___default.a.Component {
    render() {
      return __jsx("div", {
        className: "content bg-c-yellow",
        id: "footer"
      }, __jsx("p", null, __jsx(next_link__WEBPACK_IMPORTED_MODULE_1___default.a, {
        href: "/cc"
      }, __jsx("a", null, "CC"))));
    }
  
  }
  
  /* harmony default export */ __webpack_exports__["a"] = (Footer);
  
  /***/ }),
  
  /***/ "S3md":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  /***/ }),
  
  /***/ "TqRt":
  /***/ (function(module, exports) {
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      "default": obj
    };
  }
  
  module.exports = _interopRequireDefault;
  
  /***/ }),
  
  /***/ "Uh3f":
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TimeUI; });
  /* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("Y25M");
  
  
  class TimeUI {
    setWaitingTimeWithBus(target, sec, callback, stId, busRouteId, ord) {
      const interval = new _common__WEBPACK_IMPORTED_MODULE_0__[/* Interval */ "a"]();
      const id = interval.set(() => {
        const minute = sec / 60 >> 0;
        const minuteMessage = minute ? String(minute) + '분' : '';
        const secMessage = String(sec - minute * 60) + '초';
        target.text(minuteMessage + secMessage);
        sec -= 1;
  
        if (sec < 0) {
          interval.clear(id);
          callback(target, stId, busRouteId, ord);
        }
      }, 1000);
    }
  
    setWaitingTimeWithSubway(target, sec, callback, stationName, trainLineName) {
      const interval = new _common__WEBPACK_IMPORTED_MODULE_0__[/* Interval */ "a"]();
      const id = interval.set(() => {
        const minute = sec / 60 >> 0;
        const minuteMessage = minute ? String(minute) + '분' : '';
        const secMessage = String(sec - minute * 60) + '초';
        target.text(minuteMessage + secMessage);
        sec -= 1;
  
        if (sec < 0) {
          interval.clear(id);
          callback(target, stationName, trainLineName);
        }
      }, 1000);
    }
  
  }
  
  
  
  /***/ }),
  
  /***/ "X24+":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.__esModule = true;
  exports.removePathTrailingSlash = removePathTrailingSlash;
  exports.normalizePathTrailingSlash = void 0;
  /**
  * Removes the trailing slash of a path if there is one. Preserves the root path `/`.
  */
  
  function removePathTrailingSlash(path) {
    return path.endsWith('/') && path !== '/' ? path.slice(0, -1) : path;
  }
  /**
  * Normalizes the trailing slash of a path according to the `trailingSlash` option
  * in `next.config.js`.
  */
  
  
  const normalizePathTrailingSlash =  false ? undefined : removePathTrailingSlash;
  exports.normalizePathTrailingSlash = normalizePathTrailingSlash;
  
  /***/ }),
  
  /***/ "Y25M":
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Interval; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return Moment; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return Temperature; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return Random; });
  /* harmony import */ var moment__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("wy2R");
  /* harmony import */ var moment__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(moment__WEBPACK_IMPORTED_MODULE_0__);
  /* harmony import */ var config_json__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("81W9");
  var config_json__WEBPACK_IMPORTED_MODULE_1___namespace = /*#__PURE__*/__webpack_require__.t("81W9", 1);
  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  
  
  
  
  class Random {
    static all(len) {
      const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
      return this.random(characters, len);
    }
  
    static num(len) {
      const characters = '0123456789';
      return this.random(characters, len);
    }
  
    static str(len) {
      const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
      return this.random(characters, len);
    }
  
    static random(characters, len) {
      let result = '';
      const charactersLength = characters.length;
  
      for (let i = 0; i < len; i++) {
        result += characters.charAt(Math.floor(Math.random() * charactersLength));
      }
  
      return result;
    }
  
  }
  
  class Temperature {
    constructor() {
      _defineProperty(this, "KELVIN_NUM", config_json__WEBPACK_IMPORTED_MODULE_1__.KELVIN_NUM);
    }
  
    kelvinToCelsius(temp) {
      return parseFloat((temp - this.KELVIN_NUM).toFixed(0));
    }
  
  }
  
  class Moment {
    getCorrectionSec(time) {
      return Math.round((parseInt(moment__WEBPACK_IMPORTED_MODULE_0___default()().format('x')) - parseInt(moment__WEBPACK_IMPORTED_MODULE_0___default()(time).format('x'))) / 1000);
    }
  
  }
  
  class Interval {
    set(callback, ms) {
      const interval = setInterval(callback, ms);
      Interval.ids.push(interval);
      return interval;
    }
  
    clear(id) {
      clearInterval(id);
    }
  
    static clearAll() {
      for (const id of Interval.ids) {
        clearInterval(id);
      }
    }
  
  }
  
  _defineProperty(Interval, "ids", []);
  
  
  
  /***/ }),
  
  /***/ "YFqc":
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = __webpack_require__("cTJO")
  
  
  /***/ }),
  
  /***/ "YTqd":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.__esModule = true;
  exports.getRouteRegex = getRouteRegex; // this isn't importing the escape-string-regex module
  // to reduce bytes
  
  function escapeRegex(str) {
    return str.replace(/[|\\{}()[\]^$+*?.-]/g, '\\$&');
  }
  
  function parseParameter(param) {
    const optional = param.startsWith('[') && param.endsWith(']');
  
    if (optional) {
      param = param.slice(1, -1);
    }
  
    const repeat = param.startsWith('...');
  
    if (repeat) {
      param = param.slice(3);
    }
  
    return {
      key: param,
      repeat,
      optional
    };
  }
  
  function getRouteRegex(normalizedRoute) {
    const segments = (normalizedRoute.replace(/\/$/, '') || '/').slice(1).split('/');
    const groups = {};
    let groupIndex = 1;
    const parameterizedRoute = segments.map(segment => {
      if (segment.startsWith('[') && segment.endsWith(']')) {
        const {
          key,
          optional,
          repeat
        } = parseParameter(segment.slice(1, -1));
        groups[key] = {
          pos: groupIndex++,
          repeat,
          optional
        };
        return repeat ? optional ? '(?:/(.+?))?' : '/(.+?)' : '/([^/]+?)';
      } else {
        return `/${escapeRegex(segment)}`;
      }
    }).join(''); // dead code eliminate for browser since it's only needed
    // while generating routes-manifest
  
    if (true) {
      let routeKeyCharCode = 97;
      let routeKeyCharLength = 1; // builds a minimal routeKey using only a-z and minimal number of characters
  
      const getSafeRouteKey = () => {
        let routeKey = '';
  
        for (let i = 0; i < routeKeyCharLength; i++) {
          routeKey += String.fromCharCode(routeKeyCharCode);
          routeKeyCharCode++;
  
          if (routeKeyCharCode > 122) {
            routeKeyCharLength++;
            routeKeyCharCode = 97;
          }
        }
  
        return routeKey;
      };
  
      const routeKeys = {};
      let namedParameterizedRoute = segments.map(segment => {
        if (segment.startsWith('[') && segment.endsWith(']')) {
          const {
            key,
            optional,
            repeat
          } = parseParameter(segment.slice(1, -1)); // replace any non-word characters since they can break
          // the named regex
  
          let cleanedKey = key.replace(/\W/g, '');
          let invalidKey = false; // check if the key is still invalid and fallback to using a known
          // safe key
  
          if (cleanedKey.length === 0 || cleanedKey.length > 30) {
            invalidKey = true;
          }
  
          if (!isNaN(parseInt(cleanedKey.substr(0, 1)))) {
            invalidKey = true;
          }
  
          if (invalidKey) {
            cleanedKey = getSafeRouteKey();
          }
  
          routeKeys[cleanedKey] = key;
          return repeat ? optional ? `(?:/(?<${cleanedKey}>.+?))?` : `/(?<${cleanedKey}>.+?)` : `/(?<${cleanedKey}>[^/]+?)`;
        } else {
          return `/${escapeRegex(segment)}`;
        }
      }).join('');
      return {
        re: new RegExp(`^${parameterizedRoute}(?:/)?$`),
        groups,
        routeKeys,
        namedRegex: `^${namedParameterizedRoute}(?:/)?$`
      };
    }
  
    return {
      re: new RegExp(`^${parameterizedRoute}(?:/)?$`),
      groups
    };
  }
  
  /***/ }),
  
  /***/ "cDcd":
  /***/ (function(module, exports) {
  
  module.exports = require("react");
  
  /***/ }),
  
  /***/ "cDf5":
  /***/ (function(module, exports) {
  
  function _typeof(obj) {
    "@babel/helpers - typeof";
  
    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      module.exports = _typeof = function _typeof(obj) {
        return typeof obj;
      };
    } else {
      module.exports = _typeof = function _typeof(obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
    }
  
    return _typeof(obj);
  }
  
  module.exports = _typeof;
  
  /***/ }),
  
  /***/ "cTJO":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var _interopRequireWildcard = __webpack_require__("284h");
  
  exports.__esModule = true;
  exports.default = void 0;
  
  var _react = _interopRequireWildcard(__webpack_require__("cDcd"));
  
  var _router = __webpack_require__("elyg");
  
  var _router2 = __webpack_require__("nOHt");
  
  let cachedObserver;
  const listeners = new Map();
  const IntersectionObserver = false ? undefined : null;
  const prefetched = {};
  
  function getObserver() {
    // Return shared instance of IntersectionObserver if already created
    if (cachedObserver) {
      return cachedObserver;
    } // Only create shared IntersectionObserver if supported in browser
  
  
    if (!IntersectionObserver) {
      return undefined;
    }
  
    return cachedObserver = new IntersectionObserver(entries => {
      entries.forEach(entry => {
        if (!listeners.has(entry.target)) {
          return;
        }
  
        const cb = listeners.get(entry.target);
  
        if (entry.isIntersecting || entry.intersectionRatio > 0) {
          cachedObserver.unobserve(entry.target);
          listeners.delete(entry.target);
          cb();
        }
      });
    }, {
      rootMargin: '200px'
    });
  }
  
  const listenToIntersections = (el, cb) => {
    const observer = getObserver();
  
    if (!observer) {
      return () => {};
    }
  
    observer.observe(el);
    listeners.set(el, cb);
    return () => {
      try {
        observer.unobserve(el);
      } catch (err) {
        console.error(err);
      }
  
      listeners.delete(el);
    };
  };
  
  function prefetch(router, href, as, options) {
    if (true) return;
    if (!(0, _router.isLocalURL)(href)) return; // Prefetch the JSON page if asked (only in the client)
    // We need to handle a prefetch error here since we may be
    // loading with priority which can reject but we don't
    // want to force navigation since this is only a prefetch
  
    router.prefetch(href, as, options).catch(err => {
      if (false) {}
    }); // Join on an invalid URI character
  
    prefetched[href + '%' + as] = true;
  }
  
  function isModifiedEvent(event) {
    const {
      target
    } = event.currentTarget;
    return target && target !== '_self' || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || // triggers resource download
    event.nativeEvent && event.nativeEvent.which === 2;
  }
  
  function linkClicked(e, router, href, as, replace, shallow, scroll) {
    const {
      nodeName
    } = e.currentTarget;
  
    if (nodeName === 'A' && (isModifiedEvent(e) || !(0, _router.isLocalURL)(href))) {
      // ignore click for browser’s default behavior
      return;
    }
  
    e.preventDefault(); //  avoid scroll for urls with anchor refs
  
    if (scroll == null) {
      scroll = as.indexOf('#') < 0;
    } // replace state instead of push if prop is present
  
  
    router[replace ? 'replace' : 'push'](href, as, {
      shallow
    }).then(success => {
      if (!success) return;
  
      if (scroll) {
        window.scrollTo(0, 0);
        document.body.focus();
      }
    });
  }
  
  function Link(props) {
    if (false) {}
  
    const p = props.prefetch !== false;
  
    const [childElm, setChildElm] = _react.default.useState();
  
    const router = (0, _router2.useRouter)();
    const pathname = router && router.pathname || '/';
  
    const {
      href,
      as
    } = _react.default.useMemo(() => {
      const resolvedHref = (0, _router.resolveHref)(pathname, props.href);
      return {
        href: resolvedHref,
        as: props.as ? (0, _router.resolveHref)(pathname, props.as) : resolvedHref
      };
    }, [pathname, props.href, props.as]);
  
    _react.default.useEffect(() => {
      if (p && IntersectionObserver && childElm && childElm.tagName && (0, _router.isLocalURL)(href)) {
        // Join on an invalid URI character
        const isPrefetched = prefetched[href + '%' + as];
  
        if (!isPrefetched) {
          return listenToIntersections(childElm, () => {
            prefetch(router, href, as);
          });
        }
      }
    }, [p, childElm, href, as, router]);
  
    let {
      children,
      replace,
      shallow,
      scroll
    } = props; // Deprecated. Warning shown by propType check. If the children provided is a string (<Link>example</Link>) we wrap it in an <a> tag
  
    if (typeof children === 'string') {
      children = /*#__PURE__*/_react.default.createElement("a", null, children);
    } // This will return the first child, if multiple are provided it will throw an error
  
  
    const child = _react.Children.only(children);
  
    const childProps = {
      ref: el => {
        if (el) setChildElm(el);
  
        if (child && typeof child === 'object' && child.ref) {
          if (typeof child.ref === 'function') child.ref(el);else if (typeof child.ref === 'object') {
            child.ref.current = el;
          }
        }
      },
      onClick: e => {
        if (child.props && typeof child.props.onClick === 'function') {
          child.props.onClick(e);
        }
  
        if (!e.defaultPrevented) {
          linkClicked(e, router, href, as, replace, shallow, scroll);
        }
      }
    };
  
    if (p) {
      childProps.onMouseEnter = e => {
        if (!(0, _router.isLocalURL)(href)) return;
  
        if (child.props && typeof child.props.onMouseEnter === 'function') {
          child.props.onMouseEnter(e);
        }
  
        prefetch(router, href, as, {
          priority: true
        });
      };
    } // If child is an <a> tag and doesn't have a href attribute, or if the 'passHref' property is
    // defined, we specify the current 'href', so that repetition is not needed by the user
  
  
    if (props.passHref || child.type === 'a' && !('href' in child.props)) {
      childProps.href = (0, _router.addBasePath)(as);
    }
  
    return /*#__PURE__*/_react.default.cloneElement(child, childProps);
  }
  
  var _default = Link;
  exports.default = _default;
  
  /***/ }),
  
  /***/ "dZ6Y":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.__esModule = true;
  exports.default = mitt;
  /*
  MIT License
  Copyright (c) Jason Miller (https://jasonformat.com/)
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
  // This file is based on https://github.com/developit/mitt/blob/v1.1.3/src/index.js
  // It's been edited for the needs of this script
  // See the LICENSE at the top of the file
  
  function mitt() {
    const all = Object.create(null);
    return {
      on(type, handler) {
        ;
        (all[type] || (all[type] = [])).push(handler);
      },
  
      off(type, handler) {
        if (all[type]) {
          all[type].splice(all[type].indexOf(handler) >>> 0, 1);
        }
      },
  
      emit(type, ...evts) {
        // eslint-disable-next-line array-callback-return
        ;
        (all[type] || []).slice().map(handler => {
          handler(...evts);
        });
      }
  
    };
  }
  
  /***/ }),
  
  /***/ "elyg":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.__esModule = true;
  exports.hasBasePath = hasBasePath;
  exports.addBasePath = addBasePath;
  exports.delBasePath = delBasePath;
  exports.isLocalURL = isLocalURL;
  exports.resolveHref = resolveHref;
  exports.markLoadingError = markLoadingError;
  exports.default = void 0;
  
  var _normalizeTrailingSlash = __webpack_require__("X24+");
  
  var _denormalizePagePath = __webpack_require__("wkBG");
  
  var _mitt = _interopRequireDefault(__webpack_require__("dZ6Y"));
  
  var _utils = __webpack_require__("g/15");
  
  var _isDynamic = __webpack_require__("/jkW");
  
  var _parseRelativeUrl = __webpack_require__("hS4m");
  
  var _querystring = __webpack_require__("3WeD");
  
  var _resolveRewrites = _interopRequireDefault(__webpack_require__("S3md"));
  
  var _routeMatcher = __webpack_require__("gguc");
  
  var _routeRegex = __webpack_require__("YTqd");
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }
  /* global __NEXT_DATA__ */
  // tslint:disable:no-console
  
  
  const basePath =  false || '';
  
  function buildCancellationError() {
    return Object.assign(new Error('Route Cancelled'), {
      cancelled: true
    });
  }
  
  function hasBasePath(path) {
    return path === basePath || path.startsWith(basePath + '/');
  }
  
  function addBasePath(path) {
    // we only add the basepath on relative urls
    return basePath && path.startsWith('/') ? path === '/' ? (0, _normalizeTrailingSlash.normalizePathTrailingSlash)(basePath) : basePath + path : path;
  }
  
  function delBasePath(path) {
    return path.slice(basePath.length) || '/';
  }
  /**
  * Detects whether a given url is routable by the Next.js router (browser only).
  */
  
  
  function isLocalURL(url) {
    if (url.startsWith('/')) return true;
  
    try {
      // absolute urls can be local if they are on the same origin
      const locationOrigin = (0, _utils.getLocationOrigin)();
      const resolved = new URL(url, locationOrigin);
      return resolved.origin === locationOrigin && hasBasePath(resolved.pathname);
    } catch (_) {
      return false;
    }
  }
  /**
  * Resolves a given hyperlink with a certain router state (basePath not included).
  * Preserves absolute urls.
  */
  
  
  function resolveHref(currentPath, href) {
    // we use a dummy base url for relative urls
    const base = new URL(currentPath, 'http://n');
    const urlAsString = typeof href === 'string' ? href : (0, _utils.formatWithValidation)(href);
  
    try {
      const finalUrl = new URL(urlAsString, base);
      finalUrl.pathname = (0, _normalizeTrailingSlash.normalizePathTrailingSlash)(finalUrl.pathname); // if the origin didn't change, it means we received a relative href
  
      return finalUrl.origin === base.origin ? finalUrl.href.slice(finalUrl.origin.length) : finalUrl.href;
    } catch (_) {
      return urlAsString;
    }
  }
  
  const PAGE_LOAD_ERROR = Symbol('PAGE_LOAD_ERROR');
  
  function markLoadingError(err) {
    return Object.defineProperty(err, PAGE_LOAD_ERROR, {});
  }
  
  function prepareUrlAs(router, url, as) {
    // If url and as provided as an object representation,
    // we'll format them into the string version here.
    return {
      url: addBasePath(resolveHref(router.pathname, url)),
      as: as ? addBasePath(resolveHref(router.pathname, as)) : as
    };
  }
  
  const manualScrollRestoration =  false && false;
  
  function fetchRetry(url, attempts) {
    return fetch(url, {
      // Cookies are required to be present for Next.js' SSG "Preview Mode".
      // Cookies may also be required for `getServerSideProps`.
      //
      // > `fetch` won’t send cookies, unless you set the credentials init
      // > option.
      // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch
      //
      // > For maximum browser compatibility when it comes to sending &
      // > receiving cookies, always supply the `credentials: 'same-origin'`
      // > option instead of relying on the default.
      // https://github.com/github/fetch#caveats
      credentials: 'same-origin'
    }).then(res => {
      if (!res.ok) {
        if (attempts > 1 && res.status >= 500) {
          return fetchRetry(url, attempts - 1);
        }
  
        throw new Error(`Failed to load static props`);
      }
  
      return res.json();
    });
  }
  
  function fetchNextData(dataHref, isServerRender) {
    return fetchRetry(dataHref, isServerRender ? 3 : 1).catch(err => {
      // We should only trigger a server-side transition if this was caused
      // on a client-side transition. Otherwise, we'd get into an infinite
      // loop.
      if (!isServerRender) {
        markLoadingError(err);
      }
  
      throw err;
    });
  }
  
  class Router {
    /**
    * Map of all components loaded in `Router`
    */
    // Static Data Cache
    constructor(_pathname, _query, _as, {
      initialProps,
      pageLoader,
      App,
      wrapApp,
      Component,
      initialStyleSheets,
      err,
      subscription,
      isFallback
    }) {
      this.route = void 0;
      this.pathname = void 0;
      this.query = void 0;
      this.asPath = void 0;
      this.basePath = void 0;
      this.components = void 0;
      this.sdc = {};
      this.sub = void 0;
      this.clc = void 0;
      this.pageLoader = void 0;
      this._bps = void 0;
      this.events = void 0;
      this._wrapApp = void 0;
      this.isSsr = void 0;
      this.isFallback = void 0;
      this._inFlightRoute = void 0;
      this._shallow = void 0;
  
      this.onPopState = e => {
        const state = e.state;
  
        if (!state) {
          // We get state as undefined for two reasons.
          //  1. With older safari (< 8) and older chrome (< 34)
          //  2. When the URL changed with #
          //
          // In the both cases, we don't need to proceed and change the route.
          // (as it's already changed)
          // But we can simply replace the state with the new changes.
          // Actually, for (1) we don't need to nothing. But it's hard to detect that event.
          // So, doing the following for (1) does no harm.
          const {
            pathname,
            query
          } = this;
          this.changeState('replaceState', (0, _utils.formatWithValidation)({
            pathname: addBasePath(pathname),
            query
          }), (0, _utils.getURL)());
          return;
        }
  
        if (!state.__N) {
          return;
        }
  
        const {
          url,
          as,
          options
        } = state;
        const {
          pathname
        } = (0, _parseRelativeUrl.parseRelativeUrl)(url); // Make sure we don't re-render on initial load,
        // can be caused by navigating back from an external site
  
        if (this.isSsr && as === this.asPath && pathname === this.pathname) {
          return;
        } // If the downstream application returns falsy, return.
        // They will then be responsible for handling the event.
  
  
        if (this._bps && !this._bps(state)) {
          return;
        }
  
        this.change('replaceState', url, as, Object.assign({}, options, {
          shallow: options.shallow && this._shallow
        }));
      }; // represents the current component key
  
  
      this.route = (0, _normalizeTrailingSlash.removePathTrailingSlash)(_pathname); // set up the component cache (by route keys)
  
      this.components = {}; // We should not keep the cache, if there's an error
      // Otherwise, this cause issues when when going back and
      // come again to the errored page.
  
      if (_pathname !== '/_error') {
        this.components[this.route] = {
          Component,
          styleSheets: initialStyleSheets,
          props: initialProps,
          err,
          __N_SSG: initialProps && initialProps.__N_SSG,
          __N_SSP: initialProps && initialProps.__N_SSP
        };
      }
  
      this.components['/_app'] = {
        Component: App,
        styleSheets: [
          /* /_app does not need its stylesheets managed */
        ]
      }; // Backwards compat for Router.router.events
      // TODO: Should be remove the following major version as it was never documented
  
      this.events = Router.events;
      this.pageLoader = pageLoader;
      this.pathname = _pathname;
      this.query = _query; // if auto prerendered and dynamic route wait to update asPath
      // until after mount to prevent hydration mismatch
  
      this.asPath = // @ts-ignore this is temporarily global (attached to window)
      (0, _isDynamic.isDynamicRoute)(_pathname) && __NEXT_DATA__.autoExport ? _pathname : _as;
      this.basePath = basePath;
      this.sub = subscription;
      this.clc = null;
      this._wrapApp = wrapApp; // make sure to ignore extra popState in safari on navigating
      // back from external site
  
      this.isSsr = true;
      this.isFallback = isFallback;
  
      if (false) {}
    }
  
    reload() {
      window.location.reload();
    }
    /**
    * Go back in history
    */
  
  
    back() {
      window.history.back();
    }
    /**
    * Performs a `pushState` with arguments
    * @param url of the route
    * @param as masks `url` for the browser
    * @param options object you can define `shallow` and other options
    */
  
  
    push(url, as = url, options = {}) {
      ;
      ({
        url,
        as
      } = prepareUrlAs(this, url, as));
      return this.change('pushState', url, as, options);
    }
    /**
    * Performs a `replaceState` with arguments
    * @param url of the route
    * @param as masks `url` for the browser
    * @param options object you can define `shallow` and other options
    */
  
  
    replace(url, as = url, options = {}) {
      ;
      ({
        url,
        as
      } = prepareUrlAs(this, url, as));
      return this.change('replaceState', url, as, options);
    }
  
    async change(method, url, as, options) {
      if (!isLocalURL(url)) {
        window.location.href = url;
        return false;
      }
  
      if (!options._h) {
        this.isSsr = false;
      } // marking route changes as a navigation start entry
  
  
      if (_utils.ST) {
        performance.mark('routeChange');
      }
  
      if (this._inFlightRoute) {
        this.abortComponentLoad(this._inFlightRoute);
      }
  
      const cleanedAs = hasBasePath(as) ? delBasePath(as) : as;
      this._inFlightRoute = as; // If the url change is only related to a hash change
      // We should not proceed. We should only change the state.
      // WARNING: `_h` is an internal option for handing Next.js client-side
      // hydration. Your app should _never_ use this property. It may change at
      // any time without notice.
  
      if (!options._h && this.onlyAHashChange(cleanedAs)) {
        this.asPath = cleanedAs;
        Router.events.emit('hashChangeStart', as); // TODO: do we need the resolved href when only a hash change?
  
        this.changeState(method, url, as, options);
        this.scrollToHash(cleanedAs);
        this.notify(this.components[this.route]);
        Router.events.emit('hashChangeComplete', as);
        return true;
      } // The build manifest needs to be loaded before auto-static dynamic pages
      // get their query parameters to allow ensuring they can be parsed properly
      // when rewritten to
  
  
      const pages = await this.pageLoader.getPageList();
      const {
        __rewrites: rewrites
      } = await this.pageLoader.promisedBuildManifest;
      let parsed = (0, _parseRelativeUrl.parseRelativeUrl)(url);
      let {
        pathname,
        searchParams
      } = parsed;
      parsed = this._resolveHref(parsed, pages);
  
      if (parsed.pathname !== pathname) {
        pathname = parsed.pathname;
        url = (0, _utils.formatWithValidation)(parsed);
      }
  
      const query = (0, _querystring.searchParamsToUrlQuery)(searchParams); // url and as should always be prefixed with basePath by this
      // point by either next/link or router.push/replace so strip the
      // basePath from the pathname to match the pages dir 1-to-1
  
      pathname = pathname ? (0, _normalizeTrailingSlash.removePathTrailingSlash)(delBasePath(pathname)) : pathname; // If asked to change the current URL we should reload the current page
      // (not location.reload() but reload getInitialProps and other Next.js stuffs)
      // We also need to set the method = replaceState always
      // as this should not go into the history (That's how browsers work)
      // We should compare the new asPath to the current asPath, not the url
  
      if (!this.urlIsNew(cleanedAs)) {
        method = 'replaceState';
      }
  
      const route = (0, _normalizeTrailingSlash.removePathTrailingSlash)(pathname);
      const {
        shallow = false
      } = options; // we need to resolve the as value using rewrites for dynamic SSG
      // pages to allow building the data URL correctly
  
      let resolvedAs = as;
  
      if (false) {}
  
      resolvedAs = delBasePath(resolvedAs);
  
      if ((0, _isDynamic.isDynamicRoute)(route)) {
        const {
          pathname: asPathname
        } = (0, _parseRelativeUrl.parseRelativeUrl)(resolvedAs);
        const routeRegex = (0, _routeRegex.getRouteRegex)(route);
        const routeMatch = (0, _routeMatcher.getRouteMatcher)(routeRegex)(asPathname);
  
        if (!routeMatch) {
          const missingParams = Object.keys(routeRegex.groups).filter(param => !query[param]);
  
          if (missingParams.length > 0) {
            if (false) {}
  
            throw new Error(`The provided \`as\` value (${asPathname}) is incompatible with the \`href\` value (${route}). ` + `Read more: https://err.sh/vercel/next.js/incompatible-href-as`);
          }
        } else {
          // Merge params into `query`, overwriting any specified in search
          Object.assign(query, routeMatch);
        }
      }
  
      Router.events.emit('routeChangeStart', as);
  
      try {
        const routeInfo = await this.getRouteInfo(route, pathname, query, as, shallow);
        let {
          error
        } = routeInfo;
        Router.events.emit('beforeHistoryChange', as);
        this.changeState(method, url, as, options);
  
        if (false) {}
  
        await this.set(route, pathname, query, cleanedAs, routeInfo).catch(e => {
          if (e.cancelled) error = error || e;else throw e;
        });
  
        if (error) {
          Router.events.emit('routeChangeError', error, cleanedAs);
          throw error;
        }
  
        if (false) {}
  
        Router.events.emit('routeChangeComplete', as);
        return true;
      } catch (err) {
        if (err.cancelled) {
          return false;
        }
  
        throw err;
      }
    }
  
    changeState(method, url, as, options = {}) {
      if (false) {}
  
      if (method !== 'pushState' || (0, _utils.getURL)() !== as) {
        this._shallow = options.shallow;
        window.history[method]({
          url,
          as,
          options,
          __N: true
        }, // Most browsers currently ignores this parameter, although they may use it in the future.
        // Passing the empty string here should be safe against future changes to the method.
        // https://developer.mozilla.org/en-US/docs/Web/API/History/replaceState
        '', as);
      }
    }
  
    async handleRouteInfoError(err, pathname, query, as, loadErrorFail) {
      if (err.cancelled) {
        // bubble up cancellation errors
        throw err;
      }
  
      if (PAGE_LOAD_ERROR in err || loadErrorFail) {
        Router.events.emit('routeChangeError', err, as); // If we can't load the page it could be one of following reasons
        //  1. Page doesn't exists
        //  2. Page does exist in a different zone
        //  3. Internal error while loading the page
        // So, doing a hard reload is the proper way to deal with this.
  
        window.location.href = as; // Changing the URL doesn't block executing the current code path.
        // So let's throw a cancellation error stop the routing logic.
  
        throw buildCancellationError();
      }
  
      try {
        const {
          page: Component,
          styleSheets
        } = await this.fetchComponent('/_error');
        const routeInfo = {
          Component,
          styleSheets,
          err,
          error: err
        };
  
        try {
          routeInfo.props = await this.getInitialProps(Component, {
            err,
            pathname,
            query
          });
        } catch (gipErr) {
          console.error('Error in error page `getInitialProps`: ', gipErr);
          routeInfo.props = {};
        }
  
        return routeInfo;
      } catch (routeInfoErr) {
        return this.handleRouteInfoError(routeInfoErr, pathname, query, as, true);
      }
    }
  
    async getRouteInfo(route, pathname, query, as, shallow = false) {
      try {
        const cachedRouteInfo = this.components[route];
  
        if (shallow && cachedRouteInfo && this.route === route) {
          return cachedRouteInfo;
        }
  
        const routeInfo = cachedRouteInfo ? cachedRouteInfo : await this.fetchComponent(route).then(res => ({
          Component: res.page,
          styleSheets: res.styleSheets,
          __N_SSG: res.mod.__N_SSG,
          __N_SSP: res.mod.__N_SSP
        }));
        const {
          Component,
          __N_SSG,
          __N_SSP
        } = routeInfo;
  
        if (false) {}
  
        let dataHref;
  
        if (__N_SSG || __N_SSP) {
          dataHref = this.pageLoader.getDataHref((0, _utils.formatWithValidation)({
            pathname,
            query
          }), delBasePath(as), __N_SSG);
        }
  
        const props = await this._getData(() => __N_SSG ? this._getStaticData(dataHref) : __N_SSP ? this._getServerData(dataHref) : this.getInitialProps(Component, // we provide AppTree later so this needs to be `any`
        {
          pathname,
          query,
          asPath: as
        }));
        routeInfo.props = props;
        this.components[route] = routeInfo;
        return routeInfo;
      } catch (err) {
        return this.handleRouteInfoError(err, pathname, query, as);
      }
    }
  
    set(route, pathname, query, as, data) {
      this.isFallback = false;
      this.route = route;
      this.pathname = pathname;
      this.query = query;
      this.asPath = as;
      return this.notify(data);
    }
    /**
    * Callback to execute before replacing router state
    * @param cb callback to be executed
    */
  
  
    beforePopState(cb) {
      this._bps = cb;
    }
  
    onlyAHashChange(as) {
      if (!this.asPath) return false;
      const [oldUrlNoHash, oldHash] = this.asPath.split('#');
      const [newUrlNoHash, newHash] = as.split('#'); // Makes sure we scroll to the provided hash if the url/hash are the same
  
      if (newHash && oldUrlNoHash === newUrlNoHash && oldHash === newHash) {
        return true;
      } // If the urls are change, there's more than a hash change
  
  
      if (oldUrlNoHash !== newUrlNoHash) {
        return false;
      } // If the hash has changed, then it's a hash only change.
      // This check is necessary to handle both the enter and
      // leave hash === '' cases. The identity case falls through
      // and is treated as a next reload.
  
  
      return oldHash !== newHash;
    }
  
    scrollToHash(as) {
      const [, hash] = as.split('#'); // Scroll to top if the hash is just `#` with no value
  
      if (hash === '') {
        window.scrollTo(0, 0);
        return;
      } // First we check if the element by id is found
  
  
      const idEl = document.getElementById(hash);
  
      if (idEl) {
        idEl.scrollIntoView();
        return;
      } // If there's no element with the id, we check the `name` property
      // To mirror browsers
  
  
      const nameEl = document.getElementsByName(hash)[0];
  
      if (nameEl) {
        nameEl.scrollIntoView();
      }
    }
  
    urlIsNew(asPath) {
      return this.asPath !== asPath;
    }
  
    _resolveHref(parsedHref, pages) {
      const {
        pathname
      } = parsedHref;
      const cleanPathname = (0, _denormalizePagePath.denormalizePagePath)(delBasePath(pathname));
  
      if (cleanPathname === '/404' || cleanPathname === '/_error') {
        return parsedHref;
      } // handle resolving href for dynamic routes
  
  
      if (!pages.includes(cleanPathname)) {
        // eslint-disable-next-line array-callback-return
        pages.some(page => {
          if ((0, _isDynamic.isDynamicRoute)(page) && (0, _routeRegex.getRouteRegex)(page).re.test(cleanPathname)) {
            parsedHref.pathname = addBasePath(page);
            return true;
          }
        });
      }
  
      return parsedHref;
    }
    /**
    * Prefetch page code, you may wait for the data during page rendering.
    * This feature only works in production!
    * @param url the href of prefetched page
    * @param asPath the as path of the prefetched page
    */
  
  
    async prefetch(url, asPath = url, options = {}) {
      let parsed = (0, _parseRelativeUrl.parseRelativeUrl)(url);
      let {
        pathname
      } = parsed;
      const pages = await this.pageLoader.getPageList();
      parsed = this._resolveHref(parsed, pages);
  
      if (parsed.pathname !== pathname) {
        pathname = parsed.pathname;
        url = (0, _utils.formatWithValidation)(parsed);
      } // Prefetch is not supported in development mode because it would trigger on-demand-entries
  
  
      if (false) {}
  
      const route = (0, _normalizeTrailingSlash.removePathTrailingSlash)(pathname);
      await Promise.all([this.pageLoader.prefetchData(url, asPath), this.pageLoader[options.priority ? 'loadPage' : 'prefetch'](route)]);
    }
  
    async fetchComponent(route) {
      let cancelled = false;
  
      const cancel = this.clc = () => {
        cancelled = true;
      };
  
      const componentResult = await this.pageLoader.loadPage(route);
  
      if (cancelled) {
        const error = new Error(`Abort fetching component for route: "${route}"`);
        error.cancelled = true;
        throw error;
      }
  
      if (cancel === this.clc) {
        this.clc = null;
      }
  
      return componentResult;
    }
  
    _getData(fn) {
      let cancelled = false;
  
      const cancel = () => {
        cancelled = true;
      };
  
      this.clc = cancel;
      return fn().then(data => {
        if (cancel === this.clc) {
          this.clc = null;
        }
  
        if (cancelled) {
          const err = new Error('Loading initial props cancelled');
          err.cancelled = true;
          throw err;
        }
  
        return data;
      });
    }
  
    _getStaticData(dataHref) {
      const {
        href: cacheKey
      } = new URL(dataHref, window.location.href);
  
      if ( true && this.sdc[cacheKey]) {
        return Promise.resolve(this.sdc[cacheKey]);
      }
  
      return fetchNextData(dataHref, this.isSsr).then(data => {
        this.sdc[cacheKey] = data;
        return data;
      });
    }
  
    _getServerData(dataHref) {
      return fetchNextData(dataHref, this.isSsr);
    }
  
    getInitialProps(Component, ctx) {
      const {
        Component: App
      } = this.components['/_app'];
  
      const AppTree = this._wrapApp(App);
  
      ctx.AppTree = AppTree;
      return (0, _utils.loadGetInitialProps)(App, {
        AppTree,
        Component,
        router: this,
        ctx
      });
    }
  
    abortComponentLoad(as) {
      if (this.clc) {
        Router.events.emit('routeChangeError', buildCancellationError(), as);
        this.clc();
        this.clc = null;
      }
    }
  
    notify(data) {
      return this.sub(data, this.components['/_app'].Component);
    }
  
  }
  
  exports.default = Router;
  Router.events = (0, _mitt.default)();
  
  /***/ }),
  
  /***/ "g/15":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.__esModule = true;
  exports.execOnce = execOnce;
  exports.getLocationOrigin = getLocationOrigin;
  exports.getURL = getURL;
  exports.getDisplayName = getDisplayName;
  exports.isResSent = isResSent;
  exports.loadGetInitialProps = loadGetInitialProps;
  exports.formatWithValidation = formatWithValidation;
  exports.ST = exports.SP = exports.urlObjectKeys = void 0;
  
  var _formatUrl = __webpack_require__("6D7l");
  /**
  * Utils
  */
  
  
  function execOnce(fn) {
    let used = false;
    let result;
    return (...args) => {
      if (!used) {
        used = true;
        result = fn(...args);
      }
  
      return result;
    };
  }
  
  function getLocationOrigin() {
    const {
      protocol,
      hostname,
      port
    } = window.location;
    return `${protocol}//${hostname}${port ? ':' + port : ''}`;
  }
  
  function getURL() {
    const {
      href
    } = window.location;
    const origin = getLocationOrigin();
    return href.substring(origin.length);
  }
  
  function getDisplayName(Component) {
    return typeof Component === 'string' ? Component : Component.displayName || Component.name || 'Unknown';
  }
  
  function isResSent(res) {
    return res.finished || res.headersSent;
  }
  
  async function loadGetInitialProps(App, ctx) {
    if (false) { var _App$prototype; } // when called from _app `ctx` is nested in `ctx`
  
  
    const res = ctx.res || ctx.ctx && ctx.ctx.res;
  
    if (!App.getInitialProps) {
      if (ctx.ctx && ctx.Component) {
        // @ts-ignore pageProps default
        return {
          pageProps: await loadGetInitialProps(ctx.Component, ctx.ctx)
        };
      }
  
      return {};
    }
  
    const props = await App.getInitialProps(ctx);
  
    if (res && isResSent(res)) {
      return props;
    }
  
    if (!props) {
      const message = `"${getDisplayName(App)}.getInitialProps()" should resolve to an object. But found "${props}" instead.`;
      throw new Error(message);
    }
  
    if (false) {}
  
    return props;
  }
  
  const urlObjectKeys = ['auth', 'hash', 'host', 'hostname', 'href', 'path', 'pathname', 'port', 'protocol', 'query', 'search', 'slashes'];
  exports.urlObjectKeys = urlObjectKeys;
  
  function formatWithValidation(url) {
    if (false) {}
  
    return (0, _formatUrl.formatUrl)(url);
  }
  
  const SP = typeof performance !== 'undefined';
  exports.SP = SP;
  const ST = SP && typeof performance.mark === 'function' && typeof performance.measure === 'function';
  exports.ST = ST;
  
  /***/ }),
  
  /***/ "gguc":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.__esModule = true;
  exports.getRouteMatcher = getRouteMatcher;
  
  function getRouteMatcher(routeRegex) {
    const {
      re,
      groups
    } = routeRegex;
    return pathname => {
      const routeMatch = re.exec(pathname);
  
      if (!routeMatch) {
        return false;
      }
  
      const decode = param => {
        try {
          return decodeURIComponent(param);
        } catch (_) {
          const err = new Error('failed to decode param');
          err.code = 'DECODE_FAILED';
          throw err;
        }
      };
  
      const params = {};
      Object.keys(groups).forEach(slugName => {
        const g = groups[slugName];
        const m = routeMatch[g.pos];
  
        if (m !== undefined) {
          params[slugName] = ~m.indexOf('/') ? m.split('/').map(entry => decode(entry)) : g.repeat ? [decode(m)] : decode(m);
        }
      });
      return params;
    };
  }
  
  /***/ }),
  
  /***/ "hS4m":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.__esModule = true;
  exports.parseRelativeUrl = parseRelativeUrl;
  
  var _utils = __webpack_require__("g/15");
  
  const DUMMY_BASE = new URL(true ? 'http://n' : undefined);
  /**
  * Parses path-relative urls (e.g. `/hello/world?foo=bar`). If url isn't path-relative
  * (e.g. `./hello`) then at least base must be.
  * Absolute urls are rejected with one exception, in the browser, absolute urls that are on
  * the current origin will be parsed as relative
  */
  
  function parseRelativeUrl(url, base) {
    const resolvedBase = base ? new URL(base, DUMMY_BASE) : DUMMY_BASE;
    const {
      pathname,
      searchParams,
      search,
      hash,
      href,
      origin,
      protocol
    } = new URL(url, resolvedBase);
  
    if (origin !== DUMMY_BASE.origin || protocol !== 'http:' && protocol !== 'https:') {
      throw new Error('invariant: invalid relative URL');
    }
  
    return {
      pathname,
      searchParams,
      search,
      hash,
      href: href.slice(DUMMY_BASE.origin.length)
    };
  }
  
  /***/ }),
  
  /***/ "nOHt":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var _interopRequireWildcard = __webpack_require__("284h");
  
  var _interopRequireDefault = __webpack_require__("TqRt");
  
  exports.__esModule = true;
  exports.useRouter = useRouter;
  exports.makePublicRouterInstance = makePublicRouterInstance;
  exports.createRouter = exports.withRouter = exports.default = void 0;
  
  var _react = _interopRequireDefault(__webpack_require__("cDcd"));
  
  var _router2 = _interopRequireWildcard(__webpack_require__("elyg"));
  
  exports.Router = _router2.default;
  exports.NextRouter = _router2.NextRouter;
  
  var _routerContext = __webpack_require__("Osoz");
  
  var _withRouter = _interopRequireDefault(__webpack_require__("0Bsm"));
  
  exports.withRouter = _withRouter.default;
  /* global window */
  
  const singletonRouter = {
    router: null,
    // holds the actual router instance
    readyCallbacks: [],
  
    ready(cb) {
      if (this.router) return cb();
  
      if (false) {}
    }
  
  }; // Create public properties and methods of the router in the singletonRouter
  
  const urlPropertyFields = ['pathname', 'route', 'query', 'asPath', 'components', 'isFallback', 'basePath'];
  const routerEvents = ['routeChangeStart', 'beforeHistoryChange', 'routeChangeComplete', 'routeChangeError', 'hashChangeStart', 'hashChangeComplete'];
  const coreMethodFields = ['push', 'replace', 'reload', 'back', 'prefetch', 'beforePopState']; // Events is a static property on the router, the router doesn't have to be initialized to use it
  
  Object.defineProperty(singletonRouter, 'events', {
    get() {
      return _router2.default.events;
    }
  
  });
  urlPropertyFields.forEach(field => {
    // Here we need to use Object.defineProperty because, we need to return
    // the property assigned to the actual router
    // The value might get changed as we change routes and this is the
    // proper way to access it
    Object.defineProperty(singletonRouter, field, {
      get() {
        const router = getRouter();
        return router[field];
      }
  
    });
  });
  coreMethodFields.forEach(field => {
    // We don't really know the types here, so we add them later instead
    ;
  
    singletonRouter[field] = (...args) => {
      const router = getRouter();
      return router[field](...args);
    };
  });
  routerEvents.forEach(event => {
    singletonRouter.ready(() => {
      _router2.default.events.on(event, (...args) => {
        const eventField = `on${event.charAt(0).toUpperCase()}${event.substring(1)}`;
        const _singletonRouter = singletonRouter;
  
        if (_singletonRouter[eventField]) {
          try {
            _singletonRouter[eventField](...args);
          } catch (err) {
            console.error(`Error when running the Router event: ${eventField}`);
            console.error(`${err.message}\n${err.stack}`);
          }
        }
      });
    });
  });
  
  function getRouter() {
    if (!singletonRouter.router) {
      const message = 'No router instance found.\n' + 'You should only use "next/router" inside the client side of your app.\n';
      throw new Error(message);
    }
  
    return singletonRouter.router;
  } // Export the singletonRouter and this is the public API.
  
  
  var _default = singletonRouter; // Reexport the withRoute HOC
  
  exports.default = _default;
  
  function useRouter() {
    return _react.default.useContext(_routerContext.RouterContext);
  } // INTERNAL APIS
  // -------------
  // (do not use following exports inside the app)
  // Create a router and assign it as the singleton instance.
  // This is used in client side when we are initilizing the app.
  // This should **not** use inside the server.
  
  
  const createRouter = (...args) => {
    singletonRouter.router = new _router2.default(...args);
    singletonRouter.readyCallbacks.forEach(cb => cb());
    singletonRouter.readyCallbacks = [];
    return singletonRouter.router;
  }; // This function is used to create the `withRouter` router instance
  
  
  exports.createRouter = createRouter;
  
  function makePublicRouterInstance(router) {
    const _router = router;
    const instance = {};
  
    for (const property of urlPropertyFields) {
      if (typeof _router[property] === 'object') {
        instance[property] = Object.assign({}, _router[property]); // makes sure query is not stateful
  
        continue;
      }
  
      instance[property] = _router[property];
    } // Events is a static property on the router, the router doesn't have to be initialized to use it
  
  
    instance.events = _router2.default.events;
    coreMethodFields.forEach(field => {
      instance[field] = (...args) => {
        return _router[field](...args);
      };
    });
    return instance;
  }
  
  /***/ }),
  
  /***/ "sGQ9":
  /***/ (function(module, exports) {
  
  module.exports = require("mobx-react");
  
  /***/ }),
  
  /***/ "sH5C":
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return SubwayUI; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return SubwayAPI; });
  /* harmony import */ var axios__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("zr5I");
  /* harmony import */ var axios__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(axios__WEBPACK_IMPORTED_MODULE_0__);
  /* harmony import */ var _common__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("Y25M");
  /* harmony import */ var _ui__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("Uh3f");
  /* harmony import */ var config_json__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("81W9");
  var config_json__WEBPACK_IMPORTED_MODULE_3___namespace = /*#__PURE__*/__webpack_require__.t("81W9", 1);
  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  
  
  
  
  
  
  class SubwayUI {
    static setWaitingTime(target, sec, stationName, trainLineName) {
      const ui = new _ui__WEBPACK_IMPORTED_MODULE_2__[/* TimeUI */ "a"]();
      ui.setWaitingTimeWithSubway(target, sec, SubwayUI.setCurrentSubway, stationName, trainLineName);
    }
  
    static setCurrentSubway(target, stationName, trainLineName) {
      const api = new SubwayAPI();
      api.getCurrentSubway(stationName).then(data => {
        for (let d of data) {
          if (d.trainLineNm == trainLineName) {
            const subway = new Subway(d);
            const waitingSec = subway.getWaitingSec();
  
            if (waitingSec < 1) {
              target.text(subway.message);
            } else {
              SubwayUI.setWaitingTime(target, waitingSec, stationName, trainLineName);
            }
  
            break;
          }
        }
      });
    }
  
  }
  
  class SubwayAPI {
    constructor() {
      _defineProperty(this, "API_KEY", config_json__WEBPACK_IMPORTED_MODULE_3__.SUBWAY_API_KEY);
  
      _defineProperty(this, "API_HOST", config_json__WEBPACK_IMPORTED_MODULE_3__.API_HOST);
    }
  
    createSubway(stationName, direction, trainLineName, token) {
      const form = new FormData();
      form.append('station_name', stationName);
      form.append('direction', direction);
      form.append('train_line_name', trainLineName);
      form.append('token', token);
      return axios__WEBPACK_IMPORTED_MODULE_0___default.a.post(`${this.API_HOST}/public_transport/subways/create`, form).then(response => {
        return response.data.data;
      }).catch(error => {
        console.log(error);
        return {};
      });
    }
  
    deleteSubway(id, token) {
      return axios__WEBPACK_IMPORTED_MODULE_0___default.a.delete(`${this.API_HOST}/public_transport/subways/${id}/delete?token=${token}`).then(response => {
        return response.data;
      }).catch(error => {
        console.log(error);
        return {};
      });
    }
  
    getSubways(token) {
      return axios__WEBPACK_IMPORTED_MODULE_0___default.a.get(`${this.API_HOST}/public_transport/subways?token=${token}`).then(response => {
        return response.data.data.subways;
      }).catch(error => {
        console.log(error);
        return [];
      });
    }
  
    getCurrentSubway(stationName) {
      const url = 'http://swopenAPI.seoul.go.kr/api/subway/' + this.API_KEY + '/json/realtimeStationArrival/0/100/' + stationName;
      return axios__WEBPACK_IMPORTED_MODULE_0___default.a.get(url).then(response => {
        return response.data.realtimeArrivalList ? response.data.realtimeArrivalList : [];
      }).catch(error => {
        console.log(error);
        return [];
      });
    }
  
  }
  
  class Subway {
    /*
      updnLine '외선'
      barvlDt 도착예정시간
      recptnDt 생성시각
      arvlCd 도착코드
    */
    constructor(data) {
      _defineProperty(this, "data", void 0);
  
      _defineProperty(this, "apiCallTime", void 0);
  
      _defineProperty(this, "waitingSec", void 0);
  
      _defineProperty(this, "message", void 0);
  
      this.data = data;
      this.apiCallTime = this.data.recptnDt;
      this.waitingSec = parseInt(this.data.barvlDt);
      this.message = this.data.arvlMsg2;
    }
  
    getCorrectionSec() {
      const m = new _common__WEBPACK_IMPORTED_MODULE_1__[/* Moment */ "b"]();
      return m.getCorrectionSec(this.apiCallTime);
    }
  
    getWaitingSec() {
      return this.waitingSec - this.getCorrectionSec();
    }
  
  }
  
  
  
  /***/ }),
  
  /***/ "wkBG":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  exports.__esModule=true;exports.normalizePathSep=normalizePathSep;exports.denormalizePagePath=denormalizePagePath;function normalizePathSep(path){return path.replace(/\\/g,'/');}function denormalizePagePath(page){page=normalizePathSep(page);if(page.startsWith('/index/')){page=page.slice(6);}else if(page==='/index'){page='/';}return page;}
  //# sourceMappingURL=denormalize-page-path.js.map
  
  /***/ }),
  
  /***/ "wy2R":
  /***/ (function(module, exports) {
  
  module.exports = require("moment");
  
  /***/ }),
  
  /***/ "xeH2":
  /***/ (function(module, exports) {
  
  module.exports = require("jquery");
  
  /***/ }),
  
  /***/ "xnum":
  /***/ (function(module, exports) {
  
  module.exports = require("next/head");
  
  /***/ }),
  
  /***/ "zr5I":
  /***/ (function(module, exports) {
  
  module.exports = require("axios");
  
  /***/ })
  
  /******/ });