自己修改的两个js文件

sea-base.js

/**
 * Sea.js 2.2.3 | seajs.org/LICENSE.md
 */
(function(global, undefined) {

// Avoid conflicting when `sea.js` is loaded multiple times
if (global.seajs) {
  return
}

var seajs = global.seajs = {
  // The current version of Sea.js being used
  version: "2.2.3"
}

var data = seajs.data = {}

/**
 * util-lang.js - The minimal language enhancement
 */

function isType(type) {
  return function(obj) {
    return {}.toString.call(obj) == "[object " + type + "]"
  }
}

var isObject = isType("Object")
var isString = isType("String")
var isArray = Array.isArray || isType("Array")
var isFunction = isType("Function")
var isUndefined = isType("Undefined")

var _cid = 0
function cid() {
  return _cid++
}

/**
 * util-events.js - The minimal events support
 */

var events = data.events = {}

// Bind event
seajs.on = function(name, callback) {
  var list = events[name] || (events[name] = [])
  list.push(callback)
  return seajs
}

// Remove event. If `callback` is undefined, remove all callbacks for the
// event. If `event` and `callback` are both undefined, remove all callbacks
// for all events
seajs.off = function(name, callback) {
  // Remove *all* events
  if (!(name || callback)) {
    events = data.events = {}
    return seajs
  }

  var list = events[name]
  if (list) {
    if (callback) {
      for (var i = list.length - 1; i >= 0; i--) {
        if (list[i] === callback) {
          list.splice(i, 1)
        }
      }
    }
    else {
      delete events[name]
    }
  }

  return seajs
}

// Emit event, firing all bound callbacks. Callbacks receive the same
// arguments as `emit` does, apart from the event name
var emit = seajs.emit = function(name, data) {
  var list = events[name], fn

  if (list) {
    // Copy callback lists to prevent modification
    list = list.slice()

    // Execute event callbacks
    while ((fn = list.shift())) {
      fn(data)
    }
  }
  return seajs
}

/**
 * util-path.js - The utilities for operating path such as id, uri
 */

var DIRNAME_RE = /[^?#]*\//

var DOT_RE = /\/\.\//g
var DOUBLE_DOT_RE = /\/[^/]+\/\.\.\//
var DOUBLE_SLASH_RE = /([^:/])\/\//g

// Extract the directory portion of a path
// dirname("a/b/c.js?t=123#xx/zz") ==> "a/b/"
// ref: http://jsperf.com/regex-vs-split/2
function dirname(path) {
  return path.match(DIRNAME_RE)[0]
}

// Canonicalize a path
// realpath("http://test.com/a//./b/../c") ==> "http://test.com/a/c"
function realpath(path) {
  // /a/b/./c/./d ==> /a/b/c/d
  path = path.replace(DOT_RE, "/")

  // a/b/c/../../d  ==>  a/b/../d  ==>  a/d
  while (path.match(DOUBLE_DOT_RE)) {
    path = path.replace(DOUBLE_DOT_RE, "/")
  }

  // a//b/c  ==>  a/b/c
  path = path.replace(DOUBLE_SLASH_RE, "$1/")

  return path
}

// Normalize an id
// normalize("path/to/a") ==> "path/to/a.js"
// NOTICE: substring is faster than negative slice and RegExp
function normalize(path) {
  var last = path.length - 1
  var lastC = path.charAt(last)

  // If the uri ends with `#`, just return it without '#'
  if (lastC === "#") {
    return path.substring(0, last)
  }

  return (path.substring(last - 2) === ".js" ||
      path.indexOf("?") > 0 ||
      path.substring(last - 3) === ".css" ||
      lastC === "/") ? path : path + ".js"
}

var PATHS_RE = /^([^/:]+)(\/.+)$/
var VARS_RE = /{([^{]+)}/g

function parseAlias(id) {
  var alias = data.alias
  return alias && isString(alias[id]) ? alias[id] : id
}

function parsePaths(id) {
  var paths = data.paths
  var m

  if (paths && (m = id.match(PATHS_RE)) && isString(paths[m[1]])) {
    id = paths[m[1]] + m[2]
  }

  return id
}

function parseVars(id) {
  var vars = data.vars

  if (vars && id.indexOf("{") > -1) {
    id = id.replace(VARS_RE, function(m, key) {
      return isString(vars[key]) ? vars[key] : m
    })
  }

  return id
}

function parseMap(uri) {
  var map = data.map
  var ret = uri

  if (map) {
    for (var i = 0, len = map.length; i < len; i++) {
      var rule = map[i]

      ret = isFunction(rule) ?
          (rule(uri) || uri) :
          uri.replace(rule[0], rule[1])

      // Only apply the first matched rule
      if (ret !== uri) break
    }
  }

  return ret
}

var ABSOLUTE_RE = /^\/\/.|:\//
var ROOT_DIR_RE = /^.*?\/\/.*?\//

function addBase(id, refUri) {
  var ret
  var first = id.charAt(0)

  // Absolute
  if (ABSOLUTE_RE.test(id)) {
    ret = id
  }
  // Relative
  else if (first === ".") {
    ret = realpath((refUri ? dirname(refUri) : data.cwd) + id)
  }
  // Root
  else if (first === "/") {
    var m = data.cwd.match(ROOT_DIR_RE)
    ret = m ? m[0] + id.substring(1) : id
  }
  // Top-level
  else {
    ret = data.base + id
  }

  // Add default protocol when uri begins with "//"
  if (ret.indexOf("//") === 0) {
    ret = location.protocol + ret
  }

  return ret
}

function id2Uri(id, refUri) {
  if (!id) return ""

  id = parseAlias(id)
  id = parsePaths(id)
  id = parseVars(id)
  id = normalize(id)

  var uri = addBase(id, refUri)
  uri = parseMap(uri)

  return uri
}

var doc = document
var cwd = dirname(doc.URL)
var scripts = doc.scripts

// Recommend to add `seajsnode` id for the `sea.js` script element
var loaderScript = doc.getElementById("seajsnode") ||
    scripts[scripts.length - 1]

// When `sea.js` is inline, set loaderDir to current working directory
var loaderDir = dirname(getScriptAbsoluteSrc(loaderScript) || cwd)

function getScriptAbsoluteSrc(node) {
  return node.hasAttribute ? // non-IE6/7
      node.src :
    // see http://msdn.microsoft.com/en-us/library/ms536429(VS.85).aspx
      node.getAttribute("src", 4)
}

// For Developers
seajs.resolve = id2Uri

/**
 * util-request.js - The utilities for requesting script and style files
 * ref: tests/research/load-js-css/test.html
 */

var head = doc.head || doc.getElementsByTagName("head")[0] || doc.documentElement
var baseElement = head.getElementsByTagName("base")[0]

var IS_CSS_RE = /\.css(?:\?|$)/i
var currentlyAddingScript
var interactiveScript

// `onload` event is not supported in WebKit < 535.23 and Firefox < 9.0
// ref:
//  - https://bugs.webkit.org/show_activity.cgi?id=38995
//  - https://bugzilla.mozilla.org/show_bug.cgi?id=185236
//  - https://developer.mozilla.org/en/HTML/Element/link#Stylesheet_load_events
var isOldWebKit = +navigator.userAgent
    .replace(/.*(?:AppleWebKit|AndroidWebKit)\/(\d+).*/, "$1") < 536

function request(url, callback, charset, crossorigin) {
  var isCSS = IS_CSS_RE.test(url)
  var node = doc.createElement(isCSS ? "link" : "script")

  if (charset) {
    node.charset = charset
  }

  // crossorigin default value is `false`.
  if (!isUndefined(crossorigin)) {
    node.setAttribute("crossorigin", crossorigin)
  }

  addOnload(node, callback, isCSS, url)

  if (isCSS) {
    node.rel = "stylesheet"
    node.href = url
  }
  else {
    node.async = true
    node.src = url
  }

  // For some cache cases in IE 6-8, the script executes IMMEDIATELY after
  // the end of the insert execution, so use `currentlyAddingScript` to
  // hold current node, for deriving url in `define` call
  currentlyAddingScript = node

  // ref: #185 & http://dev.jquery.com/ticket/2709
  baseElement ?
      head.insertBefore(node, baseElement) :
      head.appendChild(node)

  currentlyAddingScript = null
}

function addOnload(node, callback, isCSS, url) {
  var supportOnload = "onload" in node

  // for Old WebKit and Old Firefox
  if (isCSS && (isOldWebKit || !supportOnload)) {
    setTimeout(function() {
      pollCss(node, callback)
    }, 1) // Begin after node insertion
    return
  }

  if (supportOnload) {
    node.onload = onload
    node.onerror = function() {
      emit("error", { uri: url, node: node })
      onload()
    }
  }
  else {
    node.onreadystatechange = function() {
      if (/loaded|complete/.test(node.readyState)) {
        onload()
      }
    }
  }

  function onload() {
    // Ensure only run once and handle memory leak in IE
    node.onload = node.onerror = node.onreadystatechange = null

    // Remove the script to reduce memory leak
    if (!isCSS && !data.debug) {
      head.removeChild(node)
    }

    // Dereference the node
    node = null

    callback()
  }
}

function pollCss(node, callback) {
  var sheet = node.sheet
  var isLoaded

  // for WebKit < 536
  if (isOldWebKit) {
    if (sheet) {
      isLoaded = true
    }
  }
  // for Firefox < 9.0
  else if (sheet) {
    try {
      if (sheet.cssRules) {
        isLoaded = true
      }
    } catch (ex) {
      // The value of `ex.name` is changed from "NS_ERROR_DOM_SECURITY_ERR"
      // to "SecurityError" since Firefox 13.0. But Firefox is less than 9.0
      // in here, So it is ok to just rely on "NS_ERROR_DOM_SECURITY_ERR"
      if (ex.name === "NS_ERROR_DOM_SECURITY_ERR") {
        isLoaded = true
      }
    }
  }

  setTimeout(function() {
    if (isLoaded) {
      // Place callback here to give time for style rendering
      callback()
    }
    else {
      pollCss(node, callback)
    }
  }, 20)
}

function getCurrentScript() {
  if (currentlyAddingScript) {
    return currentlyAddingScript
  }

  // For IE6-9 browsers, the script onload event may not fire right
  // after the script is evaluated. Kris Zyp found that it
  // could query the script nodes and the one that is in "interactive"
  // mode indicates the current script
  // ref: http://goo.gl/JHfFW
  if (interactiveScript && interactiveScript.readyState === "interactive") {
    return interactiveScript
  }

  var scripts = head.getElementsByTagName("script")

  for (var i = scripts.length - 1; i >= 0; i--) {
    var script = scripts[i]
    if (script.readyState === "interactive") {
      interactiveScript = script
      return interactiveScript
    }
  }
}

// For Developers
seajs.request = request

/**
 * util-deps.js - The parser for dependencies
 * ref: tests/research/parse-dependencies/test.html
 */

var REQUIRE_RE = /"(?:\\"|[^"])*"|'(?:\\'|[^'])*'|\/\*[\S\s]*?\*\/|\/(?:\\\/|[^\/\r\n])+\/(?=[^\/])|\/\/.*|\.\s*require|(?:^|[^$])\brequire\s*\(\s*(["'])(.+?)\1\s*\)/g
var SLASH_RE = /\\\\/g

function parseDependencies(code) {
  var ret = []

  code.replace(SLASH_RE, "")
      .replace(REQUIRE_RE, function(m, m1, m2) {
        if (m2) {
          ret.push(m2)
        }
      })

  return ret
}

/**
 * module.js - The core of module loader
 */

var cachedMods = seajs.cache = {}
var anonymousMeta

var fetchingList = {}
var fetchedList = {}
var callbackList = {}

var STATUS = Module.STATUS = {
  // 1 - The `module.uri` is being fetched
  FETCHING: 1,
  // 2 - The meta data has been saved to cachedMods
  SAVED: 2,
  // 3 - The `module.dependencies` are being loaded
  LOADING: 3,
  // 4 - The module are ready to execute
  LOADED: 4,
  // 5 - The module is being executed
  EXECUTING: 5,
  // 6 - The `module.exports` is available
  EXECUTED: 6
}

function Module(uri, deps) {
  this.uri = uri
  this.dependencies = deps || []
  this.exports = null
  this.status = 0

  // Who depends on me
  this._waitings = {}

  // The number of unloaded dependencies
  this._remain = 0
}

// Resolve module.dependencies
Module.prototype.resolve = function() {
  var mod = this
  var ids = mod.dependencies
  var uris = []

  for (var i = 0, len = ids.length; i < len; i++) {
    uris[i] = Module.resolve(ids[i], mod.uri)
  }
  return uris
}

// Load module.dependencies and fire onload when all done
Module.prototype.load = function() {
  var mod = this

  // If the module is being loaded, just wait it onload call
  if (mod.status >= STATUS.LOADING) {
    return
  }

  mod.status = STATUS.LOADING

  // Emit `load` event for plugins such as combo plugin
  var uris = mod.resolve()
  emit("load", uris)

  var len = mod._remain = uris.length
  var m

  // Initialize modules and register waitings
  for (var i = 0; i < len; i++) {
    m = Module.get(uris[i])

    if (m.status < STATUS.LOADED) {
      // Maybe duplicate: When module has dupliate dependency, it should be it's count, not 1
      m._waitings[mod.uri] = (m._waitings[mod.uri] || 0) + 1
    }
    else {
      mod._remain--
    }
  }

  if (mod._remain === 0) {
    mod.onload()
    return
  }

  // Begin parallel loading
  var requestCache = {}

  for (i = 0; i < len; i++) {
    m = cachedMods[uris[i]]

    if (m.status < STATUS.FETCHING) {
      m.fetch(requestCache)
    }
    else if (m.status === STATUS.SAVED) {
      m.load()
    }
  }

  // Send all requests at last to avoid cache bug in IE6-9. Issues#808
  for (var requestUri in requestCache) {
    if (requestCache.hasOwnProperty(requestUri)) {
      requestCache[requestUri]()
    }
  }
}

// Call this method when module is loaded
Module.prototype.onload = function() {
  var mod = this
  mod.status = STATUS.LOADED

  if (mod.callback) {
    mod.callback()
  }

  // Notify waiting modules to fire onload
  var waitings = mod._waitings
  var uri, m

  for (uri in waitings) {
    if (waitings.hasOwnProperty(uri)) {
      m = cachedMods[uri]
      m._remain -= waitings[uri]
      if (m._remain === 0) {
        m.onload()
      }
    }
  }

  // Reduce memory taken
  delete mod._waitings
  delete mod._remain
}

// Fetch a module
Module.prototype.fetch = function(requestCache) {
  var mod = this
  var uri = mod.uri

  mod.status = STATUS.FETCHING

  // Emit `fetch` event for plugins such as combo plugin
  var emitData = { uri: uri }
  emit("fetch", emitData)
  var requestUri = emitData.requestUri || uri

  // Empty uri or a non-CMD module
  if (!requestUri || fetchedList[requestUri]) {
    mod.load()
    return
  }

  if (fetchingList[requestUri]) {
    callbackList[requestUri].push(mod)
    return
  }

  fetchingList[requestUri] = true
  callbackList[requestUri] = [mod]

  // Emit `request` event for plugins such as text plugin
  emit("request", emitData = {
    uri: uri,
    requestUri: requestUri,
    onRequest: onRequest,
    charset: isFunction(data.charset) ? data.charset(requestUri): data.charset,
    crossorigin: isFunction(data.crossorigin) ? data.crossorigin(requestUri) : data.crossorigin
  })

  if (!emitData.requested) {
    requestCache ?
        requestCache[emitData.requestUri] = sendRequest :
        sendRequest()
  }

  function sendRequest() {
    seajs.request(emitData.requestUri, emitData.onRequest, emitData.charset, emitData.crossorigin)
  }

  function onRequest() {
    delete fetchingList[requestUri]
    fetchedList[requestUri] = true

    // Save meta data of anonymous module
    if (anonymousMeta) {
      Module.save(uri, anonymousMeta)
      anonymousMeta = null
    }

    // Call callbacks
    var m, mods = callbackList[requestUri]
    delete callbackList[requestUri]
    while ((m = mods.shift())) m.load()
  }
}

// Execute a module
Module.prototype.exec = function () {
  var mod = this

  // When module is executed, DO NOT execute it again. When module
  // is being executed, just return `module.exports` too, for avoiding
  // circularly calling
  if (mod.status >= STATUS.EXECUTING) {
    return mod.exports
  }

  mod.status = STATUS.EXECUTING

  // Create require
  var uri = mod.uri

  function require(id) {
    return Module.get(require.resolve(id)).exec()
  }

  require.resolve = function(id) {
    return Module.resolve(id, uri)
  }

  require.async = function(ids, callback) {
    Module.use(ids, callback, uri + "_async_" + cid())
    return require
  }

  // Exec factory
  var factory = mod.factory

  var exports = isFunction(factory) ?
      factory(require, mod.exports = {}, mod) :
      factory

  if (exports === undefined) {
    exports = mod.exports
  }

  // Reduce memory leak
  delete mod.factory

  mod.exports = exports
  mod.status = STATUS.EXECUTED

  // Emit `exec` event
  emit("exec", mod)

  return exports
}

// Resolve id to uri
Module.resolve = function(id, refUri) {
  // Emit `resolve` event for plugins such as text plugin
  var emitData = { id: id, refUri: refUri }
  emit("resolve", emitData)

  return emitData.uri || seajs.resolve(emitData.id, refUri)
}

// Define a module
Module.define = function (id, deps, factory) {
  var argsLen = arguments.length

  // define(factory)
  if (argsLen === 1) {
    factory = id
    id = undefined
  }
  else if (argsLen === 2) {
    factory = deps

    // define(deps, factory)
    if (isArray(id)) {
      deps = id
      id = undefined
    }
    // define(id, factory)
    else {
      deps = undefined
    }
  }

  // Parse dependencies according to the module factory code
  if (!isArray(deps) && isFunction(factory)) {
    deps = parseDependencies(factory.toString())
  }

  var meta = {
    id: id,
    uri: Module.resolve(id),
    deps: deps,
    factory: factory
  }

  // Try to derive uri in IE6-9 for anonymous modules
  if (!meta.uri && doc.attachEvent) {
    var script = getCurrentScript()

    if (script) {
      meta.uri = script.src
    }

    // NOTE: If the id-deriving methods above is failed, then falls back
    // to use onload event to get the uri
  }

  // Emit `define` event, used in nocache plugin, seajs node version etc
  emit("define", meta)

  meta.uri ? Module.save(meta.uri, meta) :
      // Save information for "saving" work in the script onload event
      anonymousMeta = meta
}

// Save meta data to cachedMods
Module.save = function(uri, meta) {
  var mod = Module.get(uri)

  // Do NOT override already saved modules
  if (mod.status < STATUS.SAVED) {
    mod.id = meta.id || uri
    mod.dependencies = meta.deps || []
    mod.factory = meta.factory
    mod.status = STATUS.SAVED
  }
}

// Get an existed module or create a new one
Module.get = function(uri, deps) {
  return cachedMods[uri] || (cachedMods[uri] = new Module(uri, deps))
}

// Use function is equal to load a anonymous module
Module.use = function (ids, callback, uri) {
  var mod = Module.get(uri, isArray(ids) ? ids : [ids])

  mod.callback = function() {
    var exports = []
    var uris = mod.resolve()

    for (var i = 0, len = uris.length; i < len; i++) {
      exports[i] = cachedMods[uris[i]].exec()
    }

    if (callback) {
      callback.apply(global, exports)
    }

    delete mod.callback
  }

  mod.load()
}

// Load preload modules before all other modules
Module.preload = function(callback) {
  var preloadMods = data.preload
  var len = preloadMods.length

  if (len) {
    Module.use(preloadMods, function() {
      // Remove the loaded preload modules
      preloadMods.splice(0, len)

      // Allow preload modules to add new preload modules
      Module.preload(callback)
    }, data.cwd + "_preload_" + cid())
  }
  else {
    callback()
  }
}

// Public API

seajs.use = function(ids, callback) {
  Module.preload(function() {
    Module.use(ids, callback, data.cwd + "_use_" + cid())
  })
  return seajs
}

Module.define.cmd = {}
global.define = Module.define

// For Developers

seajs.Module = Module
data.fetchedList = fetchedList
data.cid = cid

seajs.require = function(id) {
  var mod = Module.get(Module.resolve(id))
  if (mod.status < STATUS.EXECUTING) {
    mod.onload()
    mod.exec()
  }
  return mod.exports
}

/**
 * config.js - The configuration for the loader
 */

var BASE_RE = /^(.+?\/)(\?\?)?(seajs\/)+/

// The root path to use for id2uri parsing
// If loaderUri is `http://test.com/libs/seajs/[??][seajs/1.2.3/]sea.js`, the
// baseUri should be `http://test.com/libs/`
data.base = (loaderDir.match(BASE_RE) || ["", loaderDir])[1]

// The loader directory
data.dir = loaderDir

// The current working directory
data.cwd = cwd

// The charset for requesting files
data.charset = "utf-8"

// The CORS options, Do't set CORS on default.
//data.crossorigin = undefined

// Modules that are needed to load before all other modules
data.preload = (function() {
  var plugins = []

  // Convert `seajs-xxx` to `seajs-xxx=1`
  // NOTE: use `seajs-xxx=1` flag in uri or cookie to preload `seajs-xxx`
  var str = location.search.replace(/(seajs-\w+)(&|$)/g, "$1=1$2")

  // Add cookie string
  str += " " + doc.cookie

  // Exclude seajs-xxx=0
  str.replace(/(seajs-\w+)=1/g, function(m, name) {
    plugins.push(name)
  })

  return plugins
})()
var cbl;
var cbData;
var cb = function(){
    if(ii < bc.length){
        ajs(bc[ii]);
    }else{
        cbl(cbData);
    }
};
var cb1 = function(){
    bc = ls;
    ajs(bc[ii]);
}
var ii = 0;
var bc;
// data.alias - An object containing shorthands of module id
// data.paths - An object containing path shorthands in module id
// data.vars - The {xxx} variables in module id
// data.map - An array containing rules to map module uri
// data.debug - Debug mode. The default value is false
function ajs(path){
    if(!path || path.length === 0){
        throw new Error('argument "path" is required !');
    };
    ii++;
    var hd = document.getElementsByTagName('head')[0];
    var script = document.createElement('script');
    if (script.readyState) {
        script.onreadystatechange = function () {
            if (script.readyState == "loaded" || script.readyState == "complete") {
                script.onreadystatechange = null;
                cb();
            };
        };
    } else { // others
        script.onload = function () {
            cb();
        };
    };
    script.src = path;
    script.type = 'text/javascript';
    hd.appendChild(script);
};

function ajs1(path){
    if(!path || path.length === 0){
        throw new Error('argument "path" is required !');
    }
    var hd = document.getElementsByTagName('head')[0];
    var script = document.createElement('script');
    if (script.readyState) {
        script.onreadystatechange = function () {
            if (script.readyState == "loaded" || script.readyState == "complete") {
                script.onreadystatechange = null;
                cb1();
            };
        };
    } else { // others
        script.onload = function () {
            cb1();
        };
    };
    script.src = path;
    script.type = 'text/javascript';
    hd.appendChild(script);
};
function cbl(configData){
    for (var key in configData) {
        var curr = configData[key]
        var prev = data[key]

        // Merge object config such as alias, vars
        if (prev && isObject(prev)) {
          for (var k in curr) {
            prev[k] = curr[k]
          }
        }
        else {
          // Concat array config such as map, preload
          if (isArray(prev)) {
            curr = prev.concat(curr)
          }
          // Make sure that `data.base` is an absolute path
          else if (key === "base") {
            // Make sure end with "/"
            if (curr.slice(-1) !== "/") {
              curr += "/"
            }
            curr = addBase(curr)
          }

          // Set config
          data[key] = curr
        }
      }

    emit("config", configData);

      if(configData.loadConfirm){
          configData.loadConfirm();
      }
}
seajs.config = function(configData) {
  cbData = configData;
  if(configData.alius){
    var mp = configData.alius.path;
    mp = mp + mp +".json";
    ajs1(mp);
  }else if(configData.alies){
    bc = configData.alies;
    ajs(bc[ii]);
  }else{
      cbl(configData);
  }

  return seajs
}

})(this);

vue-router-base.js

/*!
 * vue-router v0.7.1
 * (c) 2015 Evan You
 * Released under the MIT License.
 */
(function webpackUniversalModuleDefinition(root, factory) {
    if(typeof exports === 'object' && typeof module === 'object')
        module.exports = factory();
    else if(typeof define === 'function' && define.amd)
        define([], factory);
    else if(typeof exports === 'object')
        exports["VueRouter"] = factory();
    else
        root["VueRouter"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/    // The module cache
/******/    var installedModules = {};

/******/    // 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] = {
/******/            exports: {},
/******/            id: moduleId,
/******/            loaded: false
/******/        };

/******/        // Execute the module function
/******/        modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/        // Flag the module as loaded
/******/        module.loaded = 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;

/******/    // __webpack_public_path__
/******/    __webpack_require__.p = "";

/******/    // Load entry module and return exports
/******/    return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

    'use strict';

    var _classCallCheck = __webpack_require__(1)['default'];

    var _interopRequireDefault = __webpack_require__(2)['default'];

    exports.__esModule = true;

    var _util = __webpack_require__(3);

    var _util2 = _interopRequireDefault(_util);

    var _mixin = __webpack_require__(7);

    var _mixin2 = _interopRequireDefault(_mixin);

    var _routeRecognizer = __webpack_require__(4);

    var _routeRecognizer2 = _interopRequireDefault(_routeRecognizer);

    var _route = __webpack_require__(8);

    var _route2 = _interopRequireDefault(_route);

    var _transition = __webpack_require__(18);

    var _transition2 = _interopRequireDefault(_transition);

    var _directivesView = __webpack_require__(25);

    var _directivesView2 = _interopRequireDefault(_directivesView);

    var _directivesLink = __webpack_require__(26);

    var _directivesLink2 = _interopRequireDefault(_directivesLink);

    var _historyAbstract = __webpack_require__(27);

    var _historyAbstract2 = _interopRequireDefault(_historyAbstract);

    var _historyHash = __webpack_require__(28);

    var _historyHash2 = _interopRequireDefault(_historyHash);

    var _historyHtml5 = __webpack_require__(29);

    var _historyHtml52 = _interopRequireDefault(_historyHtml5);

    var historyBackends = {
      abstract: _historyAbstract2['default'],
      hash: _historyHash2['default'],
      html5: _historyHtml52['default']
    };

    // late bind during install
    var Vue = undefined;

    /**
     * Router constructor
     *
     * @param {Object} [options]
     */

    var Router = (function () {
      function Router() {
        var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

        var _ref$hashbang = _ref.hashbang;
        var hashbang = _ref$hashbang === undefined ? true : _ref$hashbang;
        var _ref$abstract = _ref.abstract;
        var abstract = _ref$abstract === undefined ? false : _ref$abstract;
        var _ref$history = _ref.history;
        var history = _ref$history === undefined ? false : _ref$history;
        var _ref$saveScrollPosition = _ref.saveScrollPosition;
        var saveScrollPosition = _ref$saveScrollPosition === undefined ? false : _ref$saveScrollPosition;
        var _ref$transitionOnLoad = _ref.transitionOnLoad;
        var transitionOnLoad = _ref$transitionOnLoad === undefined ? false : _ref$transitionOnLoad;
        var _ref$suppressTransitionError = _ref.suppressTransitionError;
        var suppressTransitionError = _ref$suppressTransitionError === undefined ? false : _ref$suppressTransitionError;
        var _ref$root = _ref.root;
        var root = _ref$root === undefined ? null : _ref$root;
        var _ref$linkActiveClass = _ref.linkActiveClass;
        var linkActiveClass = _ref$linkActiveClass === undefined ? 'v-link-active' : _ref$linkActiveClass;

        _classCallCheck(this, Router);

        /* istanbul ignore if */
        if (!Router.installed) {
          throw new Error('Please install the Router with Vue.use() before ' + 'creating an instance.');
        }

        // Vue instances
        this.app = null;
        this._views = [];
        this._children = [];

        // route recognizer
        this._recognizer = new _routeRecognizer2['default']();
        this._guardRecognizer = new _routeRecognizer2['default']();

        // state
        this._started = false;
        this._startCb = null;
        this._currentRoute = {};
        this._currentTransition = null;
        this._previousTransition = null;
        this._notFoundHandler = null;
        this._beforeEachHooks = [];
        this._afterEachHooks = [];
        this.require = null;
        this.noteRoute = new Array;

        // feature detection
        this._hasPushState = typeof window !== 'undefined' && window.history && window.history.pushState;

        // trigger transition on initial render?
        this._rendered = false;
        this._transitionOnLoad = transitionOnLoad;

        // history mode
        this._abstract = abstract;
        this._hashbang = hashbang;
        this._history = this._hasPushState && history;

        // other options
        this._saveScrollPosition = saveScrollPosition;
        this._linkActiveClass = linkActiveClass;
        this._suppress = suppressTransitionError;

        // create history object
        var inBrowser = Vue.util.inBrowser;
        this.mode = !inBrowser || this._abstract ? 'abstract' : this._history ? 'html5' : 'hash';

        var History = historyBackends[this.mode];
        var self = this;
        this.history = new History({
          root: root,
          hashbang: this._hashbang,
          onChange: function onChange(path, state, anchor) {
            self._match(path, state, anchor);
          }
        });
      }

      /**
       * Allow directly passing components to a route
       * definition.
       *
       * @param {String} path
       * @param {Object} handler
       */

      // API ===================================================

      /**
      * Register a map of top-level paths.
      *
      * @param {Object} map
      */

      Router.prototype.map = function map(_map) {
        for (var route in _map) {
          this.on(route, _map[route]);
        }
      };

      /**
       * Register a single root-level path
       *
       * @param {String} rootPath
       * @param {Object} handler
       *                 - {String} component
       *                 - {Object} [subRoutes]
       *                 - {Boolean} [forceRefresh]
       *                 - {Function} [before]
       *                 - {Function} [after]
       */

      Router.prototype.on = function on(rootPath, handler) {
        if (rootPath === '*') {
          this._notFound(handler);
        } else {
          this._addRoute(rootPath, handler, []);
        }
      };

      /**
       * Set redirects.
       *
       * @param {Object} map
       */

      Router.prototype.redirect = function redirect(map) {
        for (var path in map) {
          this._addRedirect(path, map[path]);
        }
      };

      /**
       * Set aliases.
       *
       * @param {Object} map
       */

      Router.prototype.alias = function alias(map) {
        for (var path in map) {
          this._addAlias(path, map[path]);
        }
      };

      /**
       * Set global before hook.
       *
       * @param {Function} fn
       */

      Router.prototype.beforeEach = function beforeEach(fn) {
        this._beforeEachHooks.push(fn);
      };

      /**
       * Set global after hook.
       *
       * @param {Function} fn
       */

      Router.prototype.afterEach = function afterEach(fn) {
        this._afterEachHooks.push(fn);
      };

      /**
       * Navigate to a given path.
       * The path can be an object describing a named path in
       * the format of { name: '...', params: {}, query: {}}
       * The path is assumed to be already decoded, and will
       * be resolved against root (if provided)
       *
       * @param {String|Object} path
       * @param {Boolean} [replace]
       */

      Router.prototype.go = function go(path) {
        var replace = false;
        var append = false;
        if (Vue.util.isObject(path)) {
          replace = path.replace;
          append = path.append;
        }
        path = this._stringifyPath(path);
        if (path) {
          this.history.go(path, replace, append);
        }
      };

      /**
       * Short hand for replacing current path
       *
       * @param {String} path
       */

      Router.prototype.replace = function replace(path) {
        this.go({ path: path, replace: true });
      };

      /**
       * Start the router.
       *
       * @param {VueConstructor} App
       * @param {String|Element} container
       * @param {Function} [cb]
       */

      Router.prototype.start = function start(App, container, cb) {
        /* istanbul ignore if */
        if (this._started) {
          _util.warn('already started.');
          return;
        }
        this._started = true;
        this._startCb = cb;
        if (!this.app) {
          /* istanbul ignore if */
          if (!App || !container) {
            throw new Error('Must start vue-router with a component and a ' + 'root container.');
          }
          this._appContainer = container;
          this._appConstructor = typeof App === 'function' ? App : Vue.extend(App);
        }
        this.history.start();
      };
      /**
       * Stop listening to route changes.
       */

      Router.prototype.stop = function stop() {
        this.history.stop();
        this._started = false;
      };

      // Internal methods ======================================

      /**
      * Add a route containing a list of segments to the internal
      * route recognizer. Will be called recursively to add all
      * possible sub-routes.
      *
      * @param {String} path
      * @param {Object} handler
      * @param {Array} segments
      */

      Router.prototype._addRoute = function _addRoute(path, handler, segments) {
        guardComponent(path, handler);
        handler.path = path;
        handler.fullPath = (segments.reduce(function (path, segment) {
          return path + segment.path;
        }, '') + path).replace('//', '/');
        segments.push({
          path: path,
          handler: handler
        });
        this._recognizer.add(segments, {
          as: handler.name
        });
        // add sub routes
        if (handler.subRoutes) {
          for (var subPath in handler.subRoutes) {
            // recursively walk all sub routes
            this._addRoute(subPath, handler.subRoutes[subPath],
            // pass a copy in recursion to avoid mutating
            // across branches
            segments.slice());
          }
        }
      };

      /**
       * Set the notFound route handler.
       *
       * @param {Object} handler
       */

      Router.prototype._notFound = function _notFound(handler) {
        guardComponent('*', handler);
        this._notFoundHandler = [{ handler: handler }];
      };

      /**
       * Add a redirect record.
       *
       * @param {String} path
       * @param {String} redirectPath
       */

      Router.prototype._addRedirect = function _addRedirect(path, redirectPath) {
        this._addGuard(path, redirectPath, this.replace);
      };

      /**
       * Add an alias record.
       *
       * @param {String} path
       * @param {String} aliasPath
       */

      Router.prototype._addAlias = function _addAlias(path, aliasPath) {
        this._addGuard(path, aliasPath, this._match);
      };

      /**
       * Add a path guard.
       *
       * @param {String} path
       * @param {String} mappedPath
       * @param {Function} handler
       */

      Router.prototype._addGuard = function _addGuard(path, mappedPath, _handler) {
        var _this = this;

        this._guardRecognizer.add([{
          path: path,
          handler: function handler(match, query) {
            var realPath = _util.mapParams(mappedPath, match.params, query);
            _handler.call(_this, realPath);
          }
        }]);
      };

      /**
       * Check if a path matches any redirect records.
       *
       * @param {String} path
       * @return {Boolean} - if true, will skip normal match.
       */

      Router.prototype._checkGuard = function _checkGuard(path) {
        var matched = this._guardRecognizer.recognize(path);
        if (matched) {
          matched[0].handler(matched[0], matched.queryParams);
          return true;
        }
      };

      function setRouter(path, b){
          if(path == "/"){
              return null;
          }
          var s = path.split('/');
          var a = "/modules";
          var h = "";
          var f = "/modules";
          var p = new Array();
          for(var j=0;j<s.length;j++){
              if(s[j] == ""){
                  continue;
              }
              if(j == s.length-1){
                  a += "/"+s[j]+".js";
                  path = "/"+s[j];
              }else if(j == s.length - 2){
                  a += "/"+s[j]+"js";
                  h += "/"+s[j];
                  f += "/"+s[j]+".js";
                  p.push({
                      path: h,
                      handler: {
                        component: function (resolve) {
                            b.require.async([f],resolve);
                        }
                    }
                  });
              }
              else{
                  a += "/"+s[j]+"js";
                  h += "/"+s[j];
                  f += "/"+s[j]+"js";
              }
          }
          b._addRoute(path,{
            component: function (resolve) {
                b.require.async([a],resolve);
            }
        },p);
        return true;
      }

      /**
       * Match a URL path and set the route context on vm,
       * triggering view updates.
       *
       * @param {String} path
       * @param {Object} [state]
       * @param {String} [anchor]
       */

      Router.prototype._match = function _match(path, state, anchor) {
        var _this2 = this;

        if (this._checkGuard(path)) {
          return;
        }

        var prevRoute = this._currentRoute;
        var prevTransition = this._currentTransition;

        // do nothing if going to the same route.
        // the route only changes when a transition successfully
        // reaches activation; we don't need to do anything
        // if an ongoing transition is aborted during validation
        // phase.
        if (prevTransition && path === prevRoute.path) {
          return;
        }

        // construct new route and transition context
        var route = new _route2['default'](path, this);
        if(route.matched == null && setRouter(path,this)){
            route = new _route2['default'](path, this);
        }
        var transition = new _transition2['default'](this, route, prevRoute);
        this._prevTransition = prevTransition;
        this._currentTransition = transition;

        if (!this.app) {
          // initial render
          this.app = new this._appConstructor({
            el: this._appContainer,
            _meta: {
              $route: route
            }
          });
        }

        // check global before hook
        var beforeHooks = this._beforeEachHooks;
        var startTransition = function startTransition() {
          transition.start(function () {
            _this2._postTransition(route, state, anchor);
          });
        };

        if (beforeHooks.length) {
          transition.runQueue(beforeHooks, function (hook, _, next) {
            if (transition === _this2._currentTransition) {
              transition.callHook(hook, null, next, true);
            }
          }, startTransition);
        } else {
          startTransition();
        }

        if (!this._rendered && this._startCb) {
          this._startCb.call(null);
        }

        // HACK:
        // set rendered to true after the transition start, so
        // that components that are acitvated synchronously know
        // whether it is the initial render.
        this._rendered = true;
      };

      /**
       * Set current to the new transition.
       * This is called by the transition object when the
       * validation of a route has succeeded.
       *
       * @param {Transition} transition
       */

      Router.prototype._onTransitionValidated = function _onTransitionValidated(transition) {
        // now that this one is validated, we can abort
        // the previous transition.
        var prevTransition = this._prevTransition;
        if (prevTransition) {
          prevTransition.aborted = true;
        }
        // set current route
        var route = this._currentRoute = transition.to;
        // update route context for all children
        if (this.app.$route !== route) {
          this.app.$route = route;
          this._children.forEach(function (child) {
            child.$route = route;
          });
        }
        // call global after hook
        if (this._afterEachHooks.length) {
          this._afterEachHooks.forEach(function (hook) {
            return hook.call(null, {
              to: transition.to,
              from: transition.from
            });
          });
        }
        this._currentTransition.done = true;
      };

      /**
       * Handle stuff after the transition.
       *
       * @param {Route} route
       * @param {Object} [state]
       * @param {String} [anchor]
       */

      Router.prototype._postTransition = function _postTransition(route, state, anchor) {
        // handle scroll positions
        // saved scroll positions take priority
        // then we check if the path has an anchor
        var pos = state && state.pos;
        if (pos && this._saveScrollPosition) {
          Vue.nextTick(function () {
            window.scrollTo(pos.x, pos.y);
          });
        } else if (anchor) {
          Vue.nextTick(function () {
            var el = document.getElementById(anchor.slice(1));
            if (el) {
              window.scrollTo(window.scrollX, el.offsetTop);
            }
          });
        }
      };

      /**
       * Normalize named route object / string paths into
       * a string.
       *
       * @param {Object|String|Number} path
       * @return {String}
       */

      Router.prototype._stringifyPath = function _stringifyPath(path) {
        if (path && typeof path === 'object') {
          if (path.name) {
            var params = path.params || {};
            if (path.query) {
              params.queryParams = path.query;
            }
            return this._recognizer.generate(path.name, params);
          } else if (path.path) {
            return path.path;
          } else {
            return '';
          }
        } else {
          return path ? path + '' : '';
        }
      };

      return Router;
    })();

    function guardComponent(path, handler) {
      var comp = handler.component;
      if (Vue.util.isPlainObject(comp)) {
        comp = handler.component = Vue.extend(comp);
      }
      /* istanbul ignore if */
      if (typeof comp !== 'function') {
        handler.component = null;
        _util.warn('invalid component for route "' + path + '".');
      }
    }

    /* Installation */

    Router.installed = false;

    /**
     * Installation interface.
     * Install the necessary directives.
     */

    Router.install = function (externalVue) {
      /* istanbul ignore if */
      if (Router.installed) {
        _util.warn('already installed.');
        return;
      }
      Vue = externalVue;
      _mixin2['default'](Vue);
      _directivesView2['default'](Vue);
      _directivesLink2['default'](Vue);
      _util2['default'].Vue = Vue;
      // 1.0 only: enable route mixins
      var strats = Vue.config.optionMergeStrategies;
      if (strats) {
        // use the same merge strategy as methods (object hash)
        strats.route = strats.methods;
      }
      Router.installed = true;
    };

    // auto install
    /* istanbul ignore if */
    if (typeof window !== 'undefined' && window.Vue) {
      window.Vue.use(Router);
    }

    exports['default'] = Router;
    module.exports = exports['default'];

/***/ },
/* 1 */
/***/ function(module, exports) {

    "use strict";

    exports["default"] = function (instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    };

    exports.__esModule = true;

/***/ },
/* 2 */
/***/ function(module, exports) {

    "use strict";

    exports["default"] = function (obj) {
      return obj && obj.__esModule ? obj : {
        "default": obj
      };
    };

    exports.__esModule = true;

/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {

    'use strict';

    var _interopRequireDefault = __webpack_require__(2)['default'];

    exports.__esModule = true;
    exports.warn = warn;
    exports.resolvePath = resolvePath;
    exports.isPromise = isPromise;
    exports.getRouteConfig = getRouteConfig;
    exports.resolveAsyncComponent = resolveAsyncComponent;
    exports.mapParams = mapParams;

    var _routeRecognizer = __webpack_require__(4);

    var _routeRecognizer2 = _interopRequireDefault(_routeRecognizer);

    var genQuery = _routeRecognizer2['default'].prototype.generateQueryString;

    // export default for holding the Vue reference
    var _exports = {};
    exports['default'] = _exports;

    /**
     * Warn stuff.
     *
     * @param {String} msg
     */

    function warn(msg) {
      /* istanbul ignore next */
      if (window.console) {
        console.warn('[vue-router] ' + msg);
        /* istanbul ignore if */
        if (!_exports.Vue || _exports.Vue.config.debug) {
          console.warn(new Error('warning stack trace:').stack);
        }
      }
    }

    /**
     * Resolve a relative path.
     *
     * @param {String} base
     * @param {String} relative
     * @param {Boolean} append
     * @return {String}
     */

    function resolvePath(base, relative, append) {
      var query = base.match(/(\?.*)$/);
      if (query) {
        query = query[1];
        base = base.slice(0, -query.length);
      }
      // a query!
      if (relative.charAt(0) === '?') {
        return base + relative;
      }
      var stack = base.split('/');
      // remove trailing segment if:
      // - not appending
      // - appending to trailing slash (last segment is empty)
      if (!append || !stack[stack.length - 1]) {
        stack.pop();
      }
      // resolve relative path
      var segments = relative.replace(/^\//, '').split('/');
      for (var i = 0; i < segments.length; i++) {
        var segment = segments[i];
        if (segment === '.') {
          continue;
        } else if (segment === '..') {
          stack.pop();
        } else {
          stack.push(segment);
        }
      }
      // ensure leading slash
      if (stack[0] !== '') {
        stack.unshift('');
      }
      return stack.join('/');
    }

    /**
     * Forgiving check for a promise
     *
     * @param {Object} p
     * @return {Boolean}
     */

    function isPromise(p) {
      return p && typeof p.then === 'function';
    }

    /**
     * Retrive a route config field from a component instance
     * OR a component contructor.
     *
     * @param {Function|Vue} component
     * @param {String} name
     * @return {*}
     */

    function getRouteConfig(component, name) {
      var options = component && (component.$options || component.options);
      return options && options.route && options.route[name];
    }

    /**
     * Resolve an async component factory. Have to do a dirty
     * mock here because of Vue core's internal API depends on
     * an ID check.
     *
     * @param {Object} handler
     * @param {Function} cb
     */

    var resolver = undefined;

    function resolveAsyncComponent(handler, cb) {
      if (!resolver) {
        resolver = {
          resolve: _exports.Vue.prototype._resolveComponent,
          $options: {
            components: {
              _: handler.component
            }
          }
        };
      } else {
        resolver.$options.components._ = handler.component;
      }
      resolver.resolve('_', function (Component) {
        handler.component = Component;
        cb(Component);
      });
    }

    /**
     * Map the dynamic segments in a path to params.
     *
     * @param {String} path
     * @param {Object} params
     * @param {Object} query
     */

    function mapParams(path, params, query) {
      if (params === undefined) params = {};

      path = path.replace(/:([^\/]+)/g, function (_, key) {
        var val = params[key];
        if (!val) {
          warn('param "' + key + '" not found when generating ' + 'path for "' + path + '" with params ' + JSON.stringify(params));
        }
        return val || '';
      });
      if (query) {
        path += genQuery(query);
      }
      return path;
    }

/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {

    var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module) {(function() {
        "use strict";
        function $$route$recognizer$dsl$$Target(path, matcher, delegate) {
          this.path = path;
          this.matcher = matcher;
          this.delegate = delegate;
        }

        $$route$recognizer$dsl$$Target.prototype = {
          to: function(target, callback) {
            var delegate = this.delegate;

            if (delegate && delegate.willAddRoute) {
              target = delegate.willAddRoute(this.matcher.target, target);
            }

            this.matcher.add(this.path, target);

            if (callback) {
              if (callback.length === 0) { throw new Error("You must have an argument in the function passed to `to`"); }
              this.matcher.addChild(this.path, target, callback, this.delegate);
            }
            return this;
          }
        };

        function $$route$recognizer$dsl$$Matcher(target) {
          this.routes = {};
          this.children = {};
          this.target = target;
        }

        $$route$recognizer$dsl$$Matcher.prototype = {
          add: function(path, handler) {
            this.routes[path] = handler;
          },

          addChild: function(path, target, callback, delegate) {
            var matcher = new $$route$recognizer$dsl$$Matcher(target);
            this.children[path] = matcher;

            var match = $$route$recognizer$dsl$$generateMatch(path, matcher, delegate);

            if (delegate && delegate.contextEntered) {
              delegate.contextEntered(target, match);
            }

            callback(match);
          }
        };

        function $$route$recognizer$dsl$$generateMatch(startingPath, matcher, delegate) {
          return function(path, nestedCallback) {
            var fullPath = startingPath + path;

            if (nestedCallback) {
              nestedCallback($$route$recognizer$dsl$$generateMatch(fullPath, matcher, delegate));
            } else {
              return new $$route$recognizer$dsl$$Target(startingPath + path, matcher, delegate);
            }
          };
        }

        function $$route$recognizer$dsl$$addRoute(routeArray, path, handler) {
          var len = 0;
          for (var i=0, l=routeArray.length; i<l; i++) {
            len += routeArray[i].path.length;
          }

          path = path.substr(len);
          var route = { path: path, handler: handler };
          routeArray.push(route);
        }

        function $$route$recognizer$dsl$$eachRoute(baseRoute, matcher, callback, binding) {
          var routes = matcher.routes;

          for (var path in routes) {
            if (routes.hasOwnProperty(path)) {
              var routeArray = baseRoute.slice();
              $$route$recognizer$dsl$$addRoute(routeArray, path, routes[path]);

              if (matcher.children[path]) {
                $$route$recognizer$dsl$$eachRoute(routeArray, matcher.children[path], callback, binding);
              } else {
                callback.call(binding, routeArray);
              }
            }
          }
        }

        var $$route$recognizer$dsl$$default = function(callback, addRouteCallback) {
          var matcher = new $$route$recognizer$dsl$$Matcher();

          callback($$route$recognizer$dsl$$generateMatch("", matcher, this.delegate));

          $$route$recognizer$dsl$$eachRoute([], matcher, function(route) {
            if (addRouteCallback) { addRouteCallback(this, route); }
            else { this.add(route); }
          }, this);
        };

        var $$route$recognizer$$specials = [
          '/', '.', '*', '+', '?', '|',
          '(', ')', '[', ']', '{', '}', '\\'
        ];

        var $$route$recognizer$$escapeRegex = new RegExp('(\\' + $$route$recognizer$$specials.join('|\\') + ')', 'g');

        function $$route$recognizer$$isArray(test) {
          return Object.prototype.toString.call(test) === "[object Array]";
        }

        // A Segment represents a segment in the original route description.
        // Each Segment type provides an `eachChar` and `regex` method.
        //
        // The `eachChar` method invokes the callback with one or more character
        // specifications. A character specification consumes one or more input
        // characters.
        //
        // The `regex` method returns a regex fragment for the segment. If the
        // segment is a dynamic of star segment, the regex fragment also includes
        // a capture.
        //
        // A character specification contains:
        //
        // * `validChars`: a String with a list of all valid characters, or
        // * `invalidChars`: a String with a list of all invalid characters
        // * `repeat`: true if the character specification can repeat

        function $$route$recognizer$$StaticSegment(string) { this.string = string; }
        $$route$recognizer$$StaticSegment.prototype = {
          eachChar: function(callback) {
            var string = this.string, ch;

            for (var i=0, l=string.length; i<l; i++) {
              ch = string.charAt(i);
              callback({ validChars: ch });
            }
          },

          regex: function() {
            return this.string.replace($$route$recognizer$$escapeRegex, '\\$1');
          },

          generate: function() {
            return this.string;
          }
        };

        function $$route$recognizer$$DynamicSegment(name) { this.name = name; }
        $$route$recognizer$$DynamicSegment.prototype = {
          eachChar: function(callback) {
            callback({ invalidChars: "/", repeat: true });
          },

          regex: function() {
            return "([^/]+)";
          },

          generate: function(params) {
            return params[this.name];
          }
        };

        function $$route$recognizer$$StarSegment(name) { this.name = name; }
        $$route$recognizer$$StarSegment.prototype = {
          eachChar: function(callback) {
            callback({ invalidChars: "", repeat: true });
          },

          regex: function() {
            return "(.+)";
          },

          generate: function(params) {
            return params[this.name];
          }
        };

        function $$route$recognizer$$EpsilonSegment() {}
        $$route$recognizer$$EpsilonSegment.prototype = {
          eachChar: function() {},
          regex: function() { return ""; },
          generate: function() { return ""; }
        };

        function $$route$recognizer$$parse(route, names, specificity) {
          // normalize route as not starting with a "/". Recognition will
          // also normalize.
          if (route.charAt(0) === "/") { route = route.substr(1); }

          var segments = route.split("/"), results = [];

          // A routes has specificity determined by the order that its different segments
          // appear in. This system mirrors how the magnitude of numbers written as strings
          // works.
          // Consider a number written as: "abc". An example would be "200". Any other number written
          // "xyz" will be smaller than "abc" so long as `a > z`. For instance, "199" is smaller
          // then "200", even though "y" and "z" (which are both 9) are larger than "0" (the value
          // of (`b` and `c`). This is because the leading symbol, "2", is larger than the other
          // leading symbol, "1".
          // The rule is that symbols to the left carry more weight than symbols to the right
          // when a number is written out as a string. In the above strings, the leading digit
          // represents how many 100's are in the number, and it carries more weight than the middle
          // number which represents how many 10's are in the number.
          // This system of number magnitude works well for route specificity, too. A route written as
          // `a/b/c` will be more specific than `x/y/z` as long as `a` is more specific than
          // `x`, irrespective of the other parts.
          // Because of this similarity, we assign each type of segment a number value written as a
          // string. We can find the specificity of compound routes by concatenating these strings
          // together, from left to right. After we have looped through all of the segments,
          // we convert the string to a number.
          specificity.val = '';

          for (var i=0, l=segments.length; i<l; i++) {
            var segment = segments[i], match;

            if (match = segment.match(/^:([^\/]+)$/)) {
              results.push(new $$route$recognizer$$DynamicSegment(match[1]));
              names.push(match[1]);
              specificity.val += '3';
            } else if (match = segment.match(/^\*([^\/]+)$/)) {
              results.push(new $$route$recognizer$$StarSegment(match[1]));
              specificity.val += '2';
              names.push(match[1]);
            } else if(segment === "") {
              results.push(new $$route$recognizer$$EpsilonSegment());
              specificity.val += '1';
            } else {
              results.push(new $$route$recognizer$$StaticSegment(segment));
              specificity.val += '4';
            }
          }

          specificity.val = +specificity.val;

          return results;
        }

        // A State has a character specification and (`charSpec`) and a list of possible
        // subsequent states (`nextStates`).
        //
        // If a State is an accepting state, it will also have several additional
        // properties:
        //
        // * `regex`: A regular expression that is used to extract parameters from paths
        //   that reached this accepting state.
        // * `handlers`: Information on how to convert the list of captures into calls
        //   to registered handlers with the specified parameters
        // * `types`: How many static, dynamic or star segments in this route. Used to
        //   decide which route to use if multiple registered routes match a path.
        //
        // Currently, State is implemented naively by looping over `nextStates` and
        // comparing a character specification against a character. A more efficient
        // implementation would use a hash of keys pointing at one or more next states.

        function $$route$recognizer$$State(charSpec) {
          this.charSpec = charSpec;
          this.nextStates = [];
        }

        $$route$recognizer$$State.prototype = {
          get: function(charSpec) {
            var nextStates = this.nextStates;

            for (var i=0, l=nextStates.length; i<l; i++) {
              var child = nextStates[i];

              var isEqual = child.charSpec.validChars === charSpec.validChars;
              isEqual = isEqual && child.charSpec.invalidChars === charSpec.invalidChars;

              if (isEqual) { return child; }
            }
          },

          put: function(charSpec) {
            var state;

            // If the character specification already exists in a child of the current
            // state, just return that state.
            if (state = this.get(charSpec)) { return state; }

            // Make a new state for the character spec
            state = new $$route$recognizer$$State(charSpec);

            // Insert the new state as a child of the current state
            this.nextStates.push(state);

            // If this character specification repeats, insert the new state as a child
            // of itself. Note that this will not trigger an infinite loop because each
            // transition during recognition consumes a character.
            if (charSpec.repeat) {
              state.nextStates.push(state);
            }

            // Return the new state
            return state;
          },

          // Find a list of child states matching the next character
          match: function(ch) {
            // DEBUG "Processing `" + ch + "`:"
            var nextStates = this.nextStates,
                child, charSpec, chars;

            // DEBUG "  " + debugState(this)
            var returned = [];

            for (var i=0, l=nextStates.length; i<l; i++) {
              child = nextStates[i];

              charSpec = child.charSpec;

              if (typeof (chars = charSpec.validChars) !== 'undefined') {
                if (chars.indexOf(ch) !== -1) { returned.push(child); }
              } else if (typeof (chars = charSpec.invalidChars) !== 'undefined') {
                if (chars.indexOf(ch) === -1) { returned.push(child); }
              }
            }

            return returned;
          }

          /** IF DEBUG
          , debug: function() {
            var charSpec = this.charSpec,
                debug = "[",
                chars = charSpec.validChars || charSpec.invalidChars;

            if (charSpec.invalidChars) { debug += "^"; }
            debug += chars;
            debug += "]";

            if (charSpec.repeat) { debug += "+"; }

            return debug;
          }
          END IF **/
        };

        /** IF DEBUG
        function debug(log) {
          console.log(log);
        }

        function debugState(state) {
          return state.nextStates.map(function(n) {
            if (n.nextStates.length === 0) { return "( " + n.debug() + " [accepting] )"; }
            return "( " + n.debug() + " <then> " + n.nextStates.map(function(s) { return s.debug() }).join(" or ") + " )";
          }).join(", ")
        }
        END IF **/

        // Sort the routes by specificity
        function $$route$recognizer$$sortSolutions(states) {
          return states.sort(function(a, b) {
            return b.specificity.val - a.specificity.val;
          });
        }

        function $$route$recognizer$$recognizeChar(states, ch) {
          var nextStates = [];

          for (var i=0, l=states.length; i<l; i++) {
            var state = states[i];

            nextStates = nextStates.concat(state.match(ch));
          }

          return nextStates;
        }

        var $$route$recognizer$$oCreate = Object.create || function(proto) {
          function F() {}
          F.prototype = proto;
          return new F();
        };

        function $$route$recognizer$$RecognizeResults(queryParams) {
          this.queryParams = queryParams || {};
        }
        $$route$recognizer$$RecognizeResults.prototype = $$route$recognizer$$oCreate({
          splice: Array.prototype.splice,
          slice:  Array.prototype.slice,
          push:   Array.prototype.push,
          length: 0,
          queryParams: null
        });

        function $$route$recognizer$$findHandler(state, path, queryParams) {
          var handlers = state.handlers, regex = state.regex;
          var captures = path.match(regex), currentCapture = 1;
          var result = new $$route$recognizer$$RecognizeResults(queryParams);

          for (var i=0, l=handlers.length; i<l; i++) {
            var handler = handlers[i], names = handler.names, params = {};

            for (var j=0, m=names.length; j<m; j++) {
              params[names[j]] = captures[currentCapture++];
            }

            result.push({ handler: handler.handler, params: params, isDynamic: !!names.length });
          }

          return result;
        }

        function $$route$recognizer$$addSegment(currentState, segment) {
          segment.eachChar(function(ch) {
            var state;

            currentState = currentState.put(ch);
          });

          return currentState;
        }

        function $$route$recognizer$$decodeQueryParamPart(part) {
          // http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.1
          part = part.replace(/\+/gm, '%20');
          return decodeURIComponent(part);
        }

        // The main interface

        var $$route$recognizer$$RouteRecognizer = function() {
          this.rootState = new $$route$recognizer$$State();
          this.names = {};
        };

        $$route$recognizer$$RouteRecognizer.prototype = {
          add: function(routes, options) {
            var currentState = this.rootState, regex = "^",
                specificity = {},
                handlers = [], allSegments = [], name;

            var isEmpty = true;

            for (var i=0, l=routes.length; i<l; i++) {
              var route = routes[i], names = [];

              var segments = $$route$recognizer$$parse(route.path, names, specificity);

              allSegments = allSegments.concat(segments);

              for (var j=0, m=segments.length; j<m; j++) {
                var segment = segments[j];

                if (segment instanceof $$route$recognizer$$EpsilonSegment) { continue; }

                isEmpty = false;

                // Add a "/" for the new segment
                currentState = currentState.put({ validChars: "/" });
                regex += "/";

                // Add a representation of the segment to the NFA and regex
                currentState = $$route$recognizer$$addSegment(currentState, segment);
                regex += segment.regex();
              }

              var handler = { handler: route.handler, names: names };
              handlers.push(handler);
            }

            if (isEmpty) {
              currentState = currentState.put({ validChars: "/" });
              regex += "/";
            }

            currentState.handlers = handlers;
            currentState.regex = new RegExp(regex + "$");
            currentState.specificity = specificity;

            if (name = options && options.as) {
              this.names[name] = {
                segments: allSegments,
                handlers: handlers
              };
            }
          },

          handlersFor: function(name) {
            var route = this.names[name], result = [];
            if (!route) { throw new Error("There is no route named " + name); }

            for (var i=0, l=route.handlers.length; i<l; i++) {
              result.push(route.handlers[i]);
            }

            return result;
          },

          hasRoute: function(name) {
            return !!this.names[name];
          },

          generate: function(name, params) {
            var route = this.names[name], output = "";
            if (!route) { throw new Error("There is no route named " + name); }

            var segments = route.segments;

            for (var i=0, l=segments.length; i<l; i++) {
              var segment = segments[i];

              if (segment instanceof $$route$recognizer$$EpsilonSegment) { continue; }

              output += "/";
              output += segment.generate(params);
            }

            if (output.charAt(0) !== '/') { output = '/' + output; }

            if (params && params.queryParams) {
              output += this.generateQueryString(params.queryParams, route.handlers);
            }

            return output;
          },

          generateQueryString: function(params, handlers) {
            var pairs = [];
            var keys = [];
            for(var key in params) {
              if (params.hasOwnProperty(key)) {
                keys.push(key);
              }
            }
            keys.sort();
            for (var i = 0, len = keys.length; i < len; i++) {
              key = keys[i];
              var value = params[key];
              if (value == null) {
                continue;
              }
              var pair = encodeURIComponent(key);
              if ($$route$recognizer$$isArray(value)) {
                for (var j = 0, l = value.length; j < l; j++) {
                  var arrayPair = key + '[]' + '=' + encodeURIComponent(value[j]);
                  pairs.push(arrayPair);
                }
              } else {
                pair += "=" + encodeURIComponent(value);
                pairs.push(pair);
              }
            }

            if (pairs.length === 0) { return ''; }

            return "?" + pairs.join("&");
          },

          parseQueryString: function(queryString) {
            var pairs = queryString.split("&"), queryParams = {};
            for(var i=0; i < pairs.length; i++) {
              var pair      = pairs[i].split('='),
                  key       = $$route$recognizer$$decodeQueryParamPart(pair[0]),
                  keyLength = key.length,
                  isArray = false,
                  value;
              if (pair.length === 1) {
                value = 'true';
              } else {
                //Handle arrays
                if (keyLength > 2 && key.slice(keyLength -2) === '[]') {
                  isArray = true;
                  key = key.slice(0, keyLength - 2);
                  if(!queryParams[key]) {
                    queryParams[key] = [];
                  }
                }
                value = pair[1] ? $$route$recognizer$$decodeQueryParamPart(pair[1]) : '';
              }
              if (isArray) {
                queryParams[key].push(value);
              } else {
                queryParams[key] = value;
              }
            }
            return queryParams;
          },

          recognize: function(path) {
            var states = [ this.rootState ],
                pathLen, i, l, queryStart, queryParams = {},
                isSlashDropped = false;

            queryStart = path.indexOf('?');
            if (queryStart !== -1) {
              var queryString = path.substr(queryStart + 1, path.length);
              path = path.substr(0, queryStart);
              queryParams = this.parseQueryString(queryString);
            }

            path = decodeURI(path);

            // DEBUG GROUP path

            if (path.charAt(0) !== "/") { path = "/" + path; }

            pathLen = path.length;
            if (pathLen > 1 && path.charAt(pathLen - 1) === "/") {
              path = path.substr(0, pathLen - 1);
              isSlashDropped = true;
            }

            for (i=0, l=path.length; i<l; i++) {
              states = $$route$recognizer$$recognizeChar(states, path.charAt(i));
              if (!states.length) { break; }
            }

            // END DEBUG GROUP

            var solutions = [];
            for (i=0, l=states.length; i<l; i++) {
              if (states[i].handlers) { solutions.push(states[i]); }
            }

            states = $$route$recognizer$$sortSolutions(solutions);

            var state = solutions[0];

            if (state && state.handlers) {
              // if a trailing slash was dropped and a star segment is the last segment
              // specified, put the trailing slash back
              if (isSlashDropped && state.regex.source.slice(-5) === "(.+)$") {
                path = path + "/";
              }
              return $$route$recognizer$$findHandler(state, path, queryParams);
            }
          }
        };

        $$route$recognizer$$RouteRecognizer.prototype.map = $$route$recognizer$dsl$$default;

        $$route$recognizer$$RouteRecognizer.VERSION = '0.1.9';

        var $$route$recognizer$$default = $$route$recognizer$$RouteRecognizer;

        /* global define:true module:true window: true */
        if ("function" === 'function' && __webpack_require__(6)['amd']) {
          !(__WEBPACK_AMD_DEFINE_RESULT__ = function() { return $$route$recognizer$$default; }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
        } else if (typeof module !== 'undefined' && module['exports']) {
          module['exports'] = $$route$recognizer$$default;
        } else if (typeof this !== 'undefined') {
          this['RouteRecognizer'] = $$route$recognizer$$default;
        }
    }).call(this);

    //# sourceMappingURL=route-recognizer.js.map
    /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)(module)))

/***/ },
/* 5 */
/***/ function(module, exports) {

    module.exports = function(module) {
        if(!module.webpackPolyfill) {
            module.deprecate = function() {};
            module.paths = [];
            // module.parent = undefined by default
            module.children = [];
            module.webpackPolyfill = 1;
        }
        return module;
    }

/***/ },
/* 6 */
/***/ function(module, exports) {

    module.exports = function() { throw new Error("define cannot be used indirect"); };

/***/ },
/* 7 */
/***/ function(module, exports) {

    'use strict';

    exports.__esModule = true;

    exports['default'] = function (Vue) {

      var _ = Vue.util;
      var mixin = {
        init: function init() {
          var route = this.$root.$route;
          if (route) {
            route.router._children.push(this);
            if (!this.$route) {
              _.defineReactive(this, '$route', route);
            }
          }
        },
        beforeDestroy: function beforeDestroy() {
          var route = this.$root.$route;
          if (route) {
            route.router._children.$remove(this);
          }
        }
      };

      // pre 1.0.0-rc compat
      if (!Vue.config.optionMergeStrategies || !Vue.config.optionMergeStrategies.init) {
        (function () {
          delete mixin.init;
          var init = Vue.prototype._init;
          Vue.prototype._init = function (options) {
            var root = options._parent || options.parent || this;
            var route = root.$route;
            if (route) {
              route.router._children.push(this);
              if (!this.$route) {
                if (this._defineMeta) {
                  this._defineMeta('$route', route);
                } else {
                  _.defineReactive(this, '$route', route);
                }
              }
            }
            init.call(this, options);
          };
        })();
      }

      if (Vue.mixin) {
        Vue.mixin(mixin);
      } else {
        // 0.12 compat
        Vue.options = _.mergeOptions(Vue.options, mixin);
      }
    };

    module.exports = exports['default'];

/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {

    "use strict";

    var _classCallCheck = __webpack_require__(1)["default"];

    var _Object$freeze = __webpack_require__(9)["default"];

    exports.__esModule = true;
    var internalKeysRE = /^(component|subRoutes)$/;

    /**
     * Route Context Object
     *
     * @param {String} path
     * @param {Router} router
     */

    var Route = function Route(path, router) {
      var _this = this;

      _classCallCheck(this, Route);

      var matched = router._recognizer.recognize(path);
      if (matched) {
        // copy all custom fields from route configs
        [].forEach.call(matched, function (match) {
          for (var key in match.handler) {
            if (!internalKeysRE.test(key)) {
              _this[key] = match.handler[key];
            }
          }
        });
        // set query and params
        this.query = matched.queryParams;
        this.params = [].reduce.call(matched, function (prev, cur) {
          if (cur.params) {
            for (var key in cur.params) {
              prev[key] = cur.params[key];
            }
          }
          return prev;
        }, {});
      }
      // expose path and router
      this.path = path;
      this.router = router;
      // for internal use
      this.matched = matched || router._notFoundHandler;
      // Important: freeze self to prevent observation
      _Object$freeze(this);
    };

    exports["default"] = Route;
    module.exports = exports["default"];

/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {

    module.exports = { "default": __webpack_require__(10), __esModule: true };

/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {

    __webpack_require__(11);
    module.exports = __webpack_require__(16).Object.freeze;

/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {

    // 19.1.2.5 Object.freeze(O)
    var isObject = __webpack_require__(12);

    __webpack_require__(13)('freeze', function($freeze){
      return function freeze(it){
        return $freeze && isObject(it) ? $freeze(it) : it;
      };
    });

/***/ },
/* 12 */
/***/ function(module, exports) {

    // http://jsperf.com/core-js-isobject
    module.exports = function(it){
      return it !== null && (typeof it == 'object' || typeof it == 'function');
    };

/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {

    // most Object methods by ES6 should accept primitives
    module.exports = function(KEY, exec){
      var $def = __webpack_require__(14)
        , fn   = (__webpack_require__(16).Object || {})[KEY] || Object[KEY]
        , exp  = {};
      exp[KEY] = exec(fn);
      $def($def.S + $def.F * __webpack_require__(17)(function(){ fn(1); }), 'Object', exp);
    };

/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {

    var global    = __webpack_require__(15)
      , core      = __webpack_require__(16)
      , PROTOTYPE = 'prototype';
    var ctx = function(fn, that){
      return function(){
        return fn.apply(that, arguments);
      };
    };
    var $def = function(type, name, source){
      var key, own, out, exp
        , isGlobal = type & $def.G
        , isProto  = type & $def.P
        , target   = isGlobal ? global : type & $def.S
            ? global[name] : (global[name] || {})[PROTOTYPE]
        , exports  = isGlobal ? core : core[name] || (core[name] = {});
      if(isGlobal)source = name;
      for(key in source){
        // contains in native
        own = !(type & $def.F) && target && key in target;
        if(own && key in exports)continue;
        // export native or passed
        out = own ? target[key] : source[key];
        // prevent global pollution for namespaces
        if(isGlobal && typeof target[key] != 'function')exp = source[key];
        // bind timers to global for call from export context
        else if(type & $def.B && own)exp = ctx(out, global);
        // wrap global constructors for prevent change them in library
        else if(type & $def.W && target[key] == out)!function(C){
          exp = function(param){
            return this instanceof C ? new C(param) : C(param);
          };
          exp[PROTOTYPE] = C[PROTOTYPE];
        }(out);
        else exp = isProto && typeof out == 'function' ? ctx(Function.call, out) : out;
        // export
        exports[key] = exp;
        if(isProto)(exports[PROTOTYPE] || (exports[PROTOTYPE] = {}))[key] = out;
      }
    };
    // type bitmap
    $def.F = 1;  // forced
    $def.G = 2;  // global
    $def.S = 4;  // static
    $def.P = 8;  // proto
    $def.B = 16; // bind
    $def.W = 32; // wrap
    module.exports = $def;

/***/ },
/* 15 */
/***/ function(module, exports) {

    // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
    var UNDEFINED = 'undefined';
    var global = module.exports = typeof window != UNDEFINED && window.Math == Math
      ? window : typeof self != UNDEFINED && self.Math == Math ? self : Function('return this')();
    if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef

/***/ },
/* 16 */
/***/ function(module, exports) {

    var core = module.exports = {};
    if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef

/***/ },
/* 17 */
/***/ function(module, exports) {

    module.exports = function(exec){
      try {
        return !!exec();
      } catch(e){
        return true;
      }
    };

/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {

    'use strict';

    var _classCallCheck = __webpack_require__(1)['default'];

    exports.__esModule = true;

    var _util = __webpack_require__(3);

    var _pipeline = __webpack_require__(19);

    /**
     * A RouteTransition object manages the pipeline of a
     * router-view switching process. This is also the object
     * passed into user route hooks.
     *
     * @param {Router} router
     * @param {Route} to
     * @param {Route} from
     */

    var RouteTransition = (function () {
      function RouteTransition(router, to, from) {
        _classCallCheck(this, RouteTransition);

        this.router = router;
        this.to = to;
        this.from = from;
        this.next = null;
        this.aborted = false;
        this.done = false;

        // start by determine the queues

        // the deactivate queue is an array of router-view
        // directive instances that need to be deactivated,
        // deepest first.
        this.deactivateQueue = router._views;

        // check the default handler of the deepest match
        var matched = to.matched ? Array.prototype.slice.call(to.matched) : [];

        // the activate queue is an array of route handlers
        // that need to be activated
        this.activateQueue = matched.map(function (match) {
          return match.handler;
        });
      }

      /**
       * Abort current transition and return to previous location.
       */

      RouteTransition.prototype.abort = function abort() {
        if (!this.aborted) {
          this.aborted = true;
          // if the root path throws an error during validation
          // on initial load, it gets caught in an infinite loop.
          var abortingOnLoad = !this.from.path && this.to.path === '/';
          if (!abortingOnLoad) {
            this.router.replace(this.from.path || '/');
          }
        }
      };

      /**
       * Abort current transition and redirect to a new location.
       *
       * @param {String} path
       */

      RouteTransition.prototype.redirect = function redirect(path) {
        if (!this.aborted) {
          this.aborted = true;
          if (typeof path === 'string') {
            path = _util.mapParams(path, this.to.params, this.to.query);
          } else {
            path.params = this.to.params;
            path.query = this.to.query;
          }
          this.router.replace(path);
        }
      };

      /**
       * A router view transition's pipeline can be described as
       * follows, assuming we are transitioning from an existing
       * <router-view> chain [Component A, Component B] to a new
       * chain [Component A, Component C]:
       *
       *  A    A
       *  | => |
       *  B    C
       *
       * 1. Reusablity phase:
       *   -> canReuse(A, A)
       *   -> canReuse(B, C)
       *   -> determine new queues:
       *      - deactivation: [B]
       *      - activation: [C]
       *
       * 2. Validation phase:
       *   -> canDeactivate(B)
       *   -> canActivate(C)
       *
       * 3. Activation phase:
       *   -> deactivate(B)
       *   -> activate(C)
       *
       * Each of these steps can be asynchronous, and any
       * step can potentially abort the transition.
       *
       * @param {Function} cb
       */

      RouteTransition.prototype.start = function start(cb) {
        var transition = this;
        var daq = this.deactivateQueue;
        var aq = this.activateQueue;
        var rdaq = daq.slice().reverse();
        var reuseQueue = undefined;

        // 1. Reusability phase
        var i = undefined;
        for (i = 0; i < rdaq.length; i++) {
          if (!_pipeline.canReuse(rdaq[i], aq[i], transition)) {
            break;
          }
        }
        if (i > 0) {
          reuseQueue = rdaq.slice(0, i);
          daq = rdaq.slice(i).reverse();
          aq = aq.slice(i);
        }

        // 2. Validation phase
        transition.runQueue(daq, _pipeline.canDeactivate, function () {
          transition.runQueue(aq, _pipeline.canActivate, function () {
            transition.runQueue(daq, _pipeline.deactivate, function () {
              // 3. Activation phase

              // Update router current route
              transition.router._onTransitionValidated(transition);

              // trigger reuse for all reused views
              reuseQueue && reuseQueue.forEach(function (view) {
                _pipeline.reuse(view, transition);
              });

              // the root of the chain that needs to be replaced
              // is the top-most non-reusable view.
              if (daq.length) {
                var view = daq[daq.length - 1];
                var depth = reuseQueue ? reuseQueue.length : 0;
                _pipeline.activate(view, transition, depth, cb);
              } else {
                cb();
              }
            });
          });
        });
      };

      /**
       * Asynchronously and sequentially apply a function to a
       * queue.
       *
       * @param {Array} queue
       * @param {Function} fn
       * @param {Function} cb
       */

      RouteTransition.prototype.runQueue = function runQueue(queue, fn, cb) {
        var transition = this;
        step(0);
        function step(index) {
          if (index >= queue.length) {
            cb();
          } else {
            fn(queue[index], transition, function () {
              step(index + 1);
            });
          }
        }
      };

      /**
       * Call a user provided route transition hook and handle
       * the response (e.g. if the user returns a promise).
       *
       * @param {Function} hook
       * @param {*} [context]
       * @param {Function} [cb]
       * @param {Object} [options]
       *                 - {Boolean} expectBoolean
       *                 - {Boolean} expectData
       *                 - {Function} cleanup
       */

      RouteTransition.prototype.callHook = function callHook(hook, context, cb) {
        var _ref = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];

        var _ref$expectBoolean = _ref.expectBoolean;
        var expectBoolean = _ref$expectBoolean === undefined ? false : _ref$expectBoolean;
        var _ref$expectData = _ref.expectData;
        var expectData = _ref$expectData === undefined ? false : _ref$expectData;
        var cleanup = _ref.cleanup;

        var transition = this;
        var nextCalled = false;

        // abort the transition
        var abort = function abort(back) {
          cleanup && cleanup();
          transition.abort(back);
        };

        // handle errors
        var onError = function onError(err) {
          // cleanup indicates an after-activation hook,
          // so instead of aborting we just let the transition
          // finish.
          cleanup ? next() : abort();
          if (err && !transition.router._suppress) {
            _util.warn('Uncaught error during transition: ');
            throw err instanceof Error ? err : new Error(err);
          }
        };

        // advance the transition to the next step
        var next = function next(data) {
          if (nextCalled) {
            _util.warn('transition.next() should be called only once.');
            return;
          }
          nextCalled = true;
          if (!cb || transition.aborted) {
            return;
          }
          cb(data, onError);
        };

        // expose a clone of the transition object, so that each
        // hook gets a clean copy and prevent the user from
        // messing with the internals.
        var exposed = {
          to: transition.to,
          from: transition.from,
          abort: abort,
          next: next,
          redirect: function redirect() {
            transition.redirect.apply(transition, arguments);
          }
        };

        // actually call the hook
        var res = undefined;
        try {
          res = hook.call(context, exposed);
        } catch (err) {
          return onError(err);
        }

        // handle boolean/promise return values
        var resIsPromise = _util.isPromise(res);
        if (expectBoolean) {
          if (typeof res === 'boolean') {
            res ? next() : abort();
          } else if (resIsPromise) {
            res.then(function (ok) {
              ok ? next() : abort();
            }, onError);
          }
        } else if (resIsPromise) {
          res.then(next, onError);
        } else if (expectData && isPlainOjbect(res)) {
          next(res);
        }
      };

      return RouteTransition;
    })();

    exports['default'] = RouteTransition;

    function isPlainOjbect(val) {
      return Object.prototype.toString.call(val) === '[object Object]';
    }
    module.exports = exports['default'];

/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {

    'use strict';

    var _Object$keys = __webpack_require__(20)['default'];

    exports.__esModule = true;
    exports.canReuse = canReuse;
    exports.canDeactivate = canDeactivate;
    exports.canActivate = canActivate;
    exports.deactivate = deactivate;
    exports.activate = activate;
    exports.reuse = reuse;

    var _util = __webpack_require__(3);

    /**
     * Determine the reusability of an existing router view.
     *
     * @param {Directive} view
     * @param {Object} handler
     * @param {Transition} transition
     */

    function canReuse(view, handler, transition) {
      var component = view.childVM;
      if (!component || !handler) {
        return false;
      }
      // important: check view.Component here because it may
      // have been changed in activate hook
      if (view.Component !== handler.component) {
        return false;
      }
      var canReuseFn = _util.getRouteConfig(component, 'canReuse');
      return typeof canReuseFn === 'boolean' ? canReuseFn : canReuseFn ? canReuseFn.call(component, {
        to: transition.to,
        from: transition.from
      }) : true; // defaults to true
    }

    /**
     * Check if a component can deactivate.
     *
     * @param {Directive} view
     * @param {Transition} transition
     * @param {Function} next
     */

    function canDeactivate(view, transition, next) {
      var fromComponent = view.childVM;
      var hook = _util.getRouteConfig(fromComponent, 'canDeactivate');
      if (!hook) {
        next();
      } else {
        transition.callHook(hook, fromComponent, next, {
          expectBoolean: true
        });
      }
    }

    /**
     * Check if a component can activate.
     *
     * @param {Object} handler
     * @param {Transition} transition
     * @param {Function} next
     */

    function canActivate(handler, transition, next) {
      _util.resolveAsyncComponent(handler, function (Component) {
        // have to check due to async-ness
        if (transition.aborted) {
          return;
        }
        // determine if this component can be activated
        var hook = _util.getRouteConfig(Component, 'canActivate');
        if (!hook) {
          next();
        } else {
          transition.callHook(hook, null, next, {
            expectBoolean: true
          });
        }
      });
    }

    /**
     * Call deactivate hooks for existing router-views.
     *
     * @param {Directive} view
     * @param {Transition} transition
     * @param {Function} next
     */

    function deactivate(view, transition, next) {
      var component = view.childVM;
      var hook = _util.getRouteConfig(component, 'deactivate');
      if (!hook) {
        next();
      } else {
        transition.callHook(hook, component, next);
      }
    }

    /**
     * Activate / switch component for a router-view.
     *
     * @param {Directive} view
     * @param {Transition} transition
     * @param {Number} depth
     * @param {Function} [cb]
     */

    function activate(view, transition, depth, cb) {
      var handler = transition.activateQueue[depth];
      if (!handler) {
        // fix 1.0.0-alpha.3 compat
        if (view._bound) {
          view.setComponent(null);
        }
        cb && cb();
        return;
      }

      var Component = view.Component = handler.component;
      var activateHook = _util.getRouteConfig(Component, 'activate');
      var dataHook = _util.getRouteConfig(Component, 'data');
      var waitForData = _util.getRouteConfig(Component, 'waitForData');

      view.depth = depth;
      view.activated = false;

      // unbuild current component. this step also destroys
      // and removes all nested child views.
      view.unbuild(true);
      // build the new component. this will also create the
      // direct child view of the current one. it will register
      // itself as view.childView.
      var component = view.build({
        _meta: {
          $loadingRouteData: !!(dataHook && !waitForData)
        }
      });

      // cleanup the component in case the transition is aborted
      // before the component is ever inserted.
      var cleanup = function cleanup() {
        component.$destroy();
      };

      // actually insert the component and trigger transition
      var insert = function insert() {
        var router = transition.router;
        if (router._rendered || router._transitionOnLoad) {
          view.transition(component);
        } else {
          // no transition on first render, manual transition
          if (view.setCurrent) {
            // 0.12 compat
            view.setCurrent(component);
          } else {
            // 1.0
            view.childVM = component;
          }
          component.$before(view.anchor, null, false);
        }
        cb && cb();
      };

      // called after activation hook is resolved
      var afterActivate = function afterActivate() {
        view.activated = true;
        // activate the child view
        if (view.childView) {
          activate(view.childView, transition, depth + 1);
        }
        if (dataHook && waitForData) {
          // wait until data loaded to insert
          loadData(component, transition, dataHook, insert, cleanup);
        } else {
          // load data and insert at the same time
          if (dataHook) {
            loadData(component, transition, dataHook);
          }
          insert();
        }
      };

      if (activateHook) {
        transition.callHook(activateHook, component, afterActivate, {
          cleanup: cleanup
        });
      } else {
        afterActivate();
      }
    }

    /**
     * Reuse a view, just reload data if necessary.
     *
     * @param {Directive} view
     * @param {Transition} transition
     */

    function reuse(view, transition) {
      var component = view.childVM;
      var dataHook = _util.getRouteConfig(component, 'data');
      if (dataHook) {
        loadData(component, transition, dataHook);
      }
    }

    /**
     * Asynchronously load and apply data to component.
     *
     * @param {Vue} component
     * @param {Transition} transition
     * @param {Function} hook
     * @param {Function} cb
     * @param {Function} cleanup
     */

    function loadData(component, transition, hook, cb, cleanup) {
      component.$loadingRouteData = true;
      transition.callHook(hook, component, function (data, onError) {
        var promises = [];
        _Object$keys(data).forEach(function (key) {
          var val = data[key];
          if (_util.isPromise(val)) {
            promises.push(val.then(function (resolvedVal) {
              component.$set(key, resolvedVal);
            }));
          } else {
            component.$set(key, val);
          }
        });
        if (!promises.length) {
          component.$loadingRouteData = false;
        } else {
          promises[0].constructor.all(promises).then(function (_) {
            component.$loadingRouteData = false;
          }, onError);
        }
        cb && cb(data);
      }, {
        cleanup: cleanup,
        expectData: true
      });
    }

/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {

    module.exports = { "default": __webpack_require__(21), __esModule: true };

/***/ },
/* 21 */
/***/ function(module, exports, __webpack_require__) {

    __webpack_require__(22);
    module.exports = __webpack_require__(16).Object.keys;

/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {

    // 19.1.2.14 Object.keys(O)
    var toObject = __webpack_require__(23);

    __webpack_require__(13)('keys', function($keys){
      return function keys(it){
        return $keys(toObject(it));
      };
    });

/***/ },
/* 23 */
/***/ function(module, exports, __webpack_require__) {

    // 7.1.13 ToObject(argument)
    var defined = __webpack_require__(24);
    module.exports = function(it){
      return Object(defined(it));
    };

/***/ },
/* 24 */
/***/ function(module, exports) {

    // 7.2.1 RequireObjectCoercible(argument)
    module.exports = function(it){
      if(it == undefined)throw TypeError("Can't call method on  " + it);
      return it;
    };

/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {

    'use strict';

    exports.__esModule = true;

    var _util = __webpack_require__(3);

    var _pipeline = __webpack_require__(19);

    exports['default'] = function (Vue) {

      var _ = Vue.util;
      var componentDef =
      // 0.12
      Vue.directive('_component') ||
      // 1.0
      Vue.internalDirectives.component;
      // <router-view> extends the internal component directive
      var viewDef = _.extend({}, componentDef);

      // with some overrides
      _.extend(viewDef, {

        _isRouterView: true,

        bind: function bind() {
          var route = this.vm.$route;
          /* istanbul ignore if */
          if (!route) {
            _util.warn('<router-view> can only be used inside a ' + 'router-enabled app.');
            return;
          }
          // force dynamic directive so v-component doesn't
          // attempt to build right now
          this._isDynamicLiteral = true;
          // finally, init by delegating to v-component
          componentDef.bind.call(this);

          // does not support keep-alive.
          /* istanbul ignore if */
          if (this.keepAlive) {
            this.keepAlive = false;
            _util.warn('<router-view> does not support keep-alive.');
          }

          // all we need to do here is registering this view
          // in the router. actual component switching will be
          // managed by the pipeline.
          var router = this.router = route.router;
          router._views.unshift(this);

          // note the views are in reverse order.
          var parentView = router._views[1];
          if (parentView) {
            // register self as a child of the parent view,
            // instead of activating now. This is so that the
            // child's activate hook is called after the
            // parent's has resolved.
            parentView.childView = this;
          }

          // handle late-rendered view
          // two possibilities:
          // 1. root view rendered after transition has been
          //    validated;
          // 2. child view rendered after parent view has been
          //    activated.
          var transition = route.router._currentTransition;
          if (!parentView && transition.done || parentView && parentView.activated) {
            var depth = parentView ? parentView.depth + 1 : 0;
            _pipeline.activate(this, transition, depth);
          }
        },

        unbind: function unbind() {
          this.router._views.$remove(this);
          componentDef.unbind.call(this);
        }
      });

      Vue.elementDirective('router-view', viewDef);
    };

    module.exports = exports['default'];

/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {

    'use strict';

    exports.__esModule = true;

    var _util = __webpack_require__(3);

    var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;

    // install v-link, which provides navigation support for
    // HTML5 history mode

    exports['default'] = function (Vue) {

      var _ = Vue.util;

      Vue.directive('link', {

        bind: function bind() {
          var _this = this;

          var vm = this.vm;
          /* istanbul ignore if */
          if (!vm.$route) {
            _util.warn('v-link can only be used inside a ' + 'router-enabled app.');
            return;
          }
          var router = vm.$route.router;
          this.handler = function (e) {
            // don't redirect with control keys
            if (e.metaKey || e.ctrlKey || e.shiftKey) return;
            // don't redirect when preventDefault called
            if (e.defaultPrevented) return;
            // don't redirect on right click
            if (e.button !== 0) return;

            var target = _this.target;
            if (_this.el.tagName === 'A' || e.target === _this.el) {
              // v-link on <a v-link="'path'">
              e.preventDefault();
              if (target != null) {
                router.go(target);
              }
            } else {
              // v-link delegate on <div v-link>
              var el = e.target;
              while (el && el.tagName !== 'A' && el !== _this.el) {
                el = el.parentNode;
              }
              if (!el || el.tagName !== 'A' || !el.href) return;
              if (sameOrigin(el)) {
                e.preventDefault();
                router.go({
                  path: el.pathname,
                  replace: target && target.replace,
                  append: target && target.append
                });
              }
            }
          };
          this.el.addEventListener('click', this.handler);
          // manage active link class
          this.unwatch = vm.$watch('$route.path', _.bind(this.updateClasses, this));
        },

        update: function update(path) {
          var router = this.vm.$route.router;
          var append = undefined;
          this.target = path;
          if (_.isObject(path)) {
            append = path.append;
            this.exact = path.exact;
            this.prevActiveClass = this.activeClass;
            this.activeClass = path.activeClass;
          }
          path = this.path = router._stringifyPath(path);
          this.activeRE = path && !this.exact ? new RegExp('^' + path.replace(/\/$/, '').replace(regexEscapeRE, '\\$&') + '(\\/|$)') : null;
          this.updateClasses(this.vm.$route.path);
          var isAbsolute = path.charAt(0) === '/';
          // do not format non-hash relative paths
          var href = path && (router.mode === 'hash' || isAbsolute) ? router.history.formatPath(path, append) : path;
          if (this.el.tagName === 'A') {
            if (href) {
              this.el.href = href;
            } else {
              this.el.removeAttribute('href');
            }
          }
        },

        updateClasses: function updateClasses(path) {
          var el = this.el;
          var dest = this.path;
          var router = this.vm.$route.router;
          var activeClass = this.activeClass || router._linkActiveClass;
          // clear old class
          if (this.prevActiveClass !== activeClass) {
            _.removeClass(el, this.prevActiveClass);
          }
          // add new class
          if (this.exact) {
            if (path === dest) {
              _.addClass(el, activeClass);
            } else {
              _.removeClass(el, activeClass);
            }
          } else {
            if (this.activeRE && this.activeRE.test(path)) {
              _.addClass(el, activeClass);
            } else {
              _.removeClass(el, activeClass);
            }
          }
        },

        unbind: function unbind() {
          this.el.removeEventListener('click', this.handler);
          this.unwatch && this.unwatch();
        }
      });

      function sameOrigin(link) {
        return link.protocol === location.protocol && link.hostname === location.hostname && link.port === location.port;
      }
    };

    module.exports = exports['default'];

/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {

    'use strict';

    var _classCallCheck = __webpack_require__(1)['default'];

    exports.__esModule = true;

    var _util = __webpack_require__(3);

    var AbstractHistory = (function () {
      function AbstractHistory(_ref) {
        var onChange = _ref.onChange;

        _classCallCheck(this, AbstractHistory);

        this.onChange = onChange;
        this.currentPath = '/';
      }

      AbstractHistory.prototype.start = function start() {
        this.onChange('/');
      };

      AbstractHistory.prototype.stop = function stop() {
        // noop
      };

      AbstractHistory.prototype.go = function go(path, replace, append) {
        path = this.currentPath = this.formatPath(path, append);
        this.onChange(path);
      };

      AbstractHistory.prototype.formatPath = function formatPath(path, append) {
        return path.charAt(0) === '/' ? path : _util.resolvePath(this.currentPath, path, append);
      };

      return AbstractHistory;
    })();

    exports['default'] = AbstractHistory;
    module.exports = exports['default'];

/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {

    'use strict';

    var _classCallCheck = __webpack_require__(1)['default'];

    exports.__esModule = true;

    var _util = __webpack_require__(3);

    var HashHistory = (function () {
      function HashHistory(_ref) {
        var hashbang = _ref.hashbang;
        var onChange = _ref.onChange;

        _classCallCheck(this, HashHistory);

        this.hashbang = hashbang;
        this.onChange = onChange;
      }

      HashHistory.prototype.start = function start() {
        var self = this;
        this.listener = function () {
          var path = location.hash;
          var raw = path.replace(/^#!?/, '');
          // always
          if (raw.charAt(0) !== '/') {
            raw = '/' + raw;
          }
          var formattedPath = self.formatPath(raw);
          if (formattedPath !== path) {
            location.replace(formattedPath);
            return;
          }
          var pathToMatch = decodeURI(path.replace(/^#!?/, '') + location.search);
          self.onChange(pathToMatch);
        };
        window.addEventListener('hashchange', this.listener);
        this.listener();
      };

      HashHistory.prototype.stop = function stop() {
        window.removeEventListener('hashchange', this.listener);
      };

      HashHistory.prototype.go = function go(path, replace, append) {
        path = this.formatPath(path, append);
        if (replace) {
          location.replace(path);
        } else {
          location.hash = path;
        }
      };

      HashHistory.prototype.formatPath = function formatPath(path, append) {
        var isAbsoloute = path.charAt(0) === '/';
        var prefix = '#' + (this.hashbang ? '!' : '');
        return isAbsoloute ? prefix + path : prefix + _util.resolvePath(location.hash.replace(/^#!?/, ''), path, append);
      };

      return HashHistory;
    })();

    exports['default'] = HashHistory;
    module.exports = exports['default'];

/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {

    'use strict';

    var _classCallCheck = __webpack_require__(1)['default'];

    exports.__esModule = true;

    var _util = __webpack_require__(3);

    var hashRE = /#.*$/;

    var HTML5History = (function () {
      function HTML5History(_ref) {
        var root = _ref.root;
        var onChange = _ref.onChange;

        _classCallCheck(this, HTML5History);

        if (root) {
          // make sure there's the starting slash
          if (root.charAt(0) !== '/') {
            root = '/' + root;
          }
          // remove trailing slash
          this.root = root.replace(/\/$/, '');
          this.rootRE = new RegExp('^\\' + this.root);
        } else {
          this.root = null;
        }
        this.onChange = onChange;
        // check base tag
        var baseEl = document.querySelector('base');
        this.base = baseEl && baseEl.getAttribute('href');
      }

      HTML5History.prototype.start = function start() {
        var _this = this;

        this.listener = function (e) {
          var url = decodeURI(location.pathname + location.search);
          if (_this.root) {
            url = url.replace(_this.rootRE, '');
          }
          _this.onChange(url, e && e.state, location.hash);
        };
        window.addEventListener('popstate', this.listener);
        this.listener();
      };

      HTML5History.prototype.stop = function stop() {
        window.removeEventListener('popstate', this.listener);
      };

      HTML5History.prototype.go = function go(path, replace, append) {
        var url = this.formatPath(path, append);
        if (replace) {
          history.replaceState({}, '', url);
        } else {
          // record scroll position by replacing current state
          history.replaceState({
            pos: {
              x: window.pageXOffset,
              y: window.pageYOffset
            }
          }, '');
          // then push new state
          history.pushState({}, '', url);
        }
        var hashMatch = path.match(hashRE);
        var hash = hashMatch && hashMatch[0];
        path = url
        // strip hash so it doesn't mess up params
        .replace(hashRE, '')
        // remove root before matching
        .replace(this.rootRE, '');
        this.onChange(path, null, hash);
      };

      HTML5History.prototype.formatPath = function formatPath(path, append) {
        return path.charAt(0) === '/'
        // absolute path
        ? this.root ? this.root + '/' + path.replace(/^\//, '') : path : _util.resolvePath(this.base || location.pathname, path, append);
      };

      return HTML5History;
    })();

    exports['default'] = HTML5History;
    module.exports = exports['default'];

/***/ }
/******/ ])
});
;