├── .gitignore
├── Gemfile
├── LICENSE.md
├── Rakefile
├── Readme.md
├── lib
    ├── vuejs-rails.rb
    └── vuejs-rails
    │   ├── engine.rb
    │   └── version.rb
├── vendor
    └── assets
    │   └── javascripts
    │       ├── dist
    │           ├── vue-resource.js
    │           ├── vue-resource.min.js
    │           ├── vue-router.js
    │           ├── vue-router.min.js
    │           ├── vue.js
    │           ├── vue.min.js
    │           ├── vuex.js
    │           └── vuex.min.js
    │       ├── vue-resource.js.erb
    │       ├── vue-router.js.erb
    │       ├── vue.js.erb
    │       └── vuex.js.erb
└── vuejs-rails.gemspec


/.gitignore:
--------------------------------------------------------------------------------
1 | *.gem
2 | .bundle
3 | Gemfile.lock
4 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
1 | source "http://rubygems.org"
2 | gemspec
3 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2013 - 2017 Adam Butler
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
1 | require "bundler/gem_tasks"
2 | 


--------------------------------------------------------------------------------
/Readme.md:
--------------------------------------------------------------------------------
 1 | # vuejs-rails
 2 | 
 3 | [![Gem](https://img.shields.io/gem/v/vuejs-rails.svg)](https://rubygems.org/gems/vuejs-rails)
 4 | [![Gem](https://img.shields.io/gem/dt/vuejs-rails.svg)](https://rubygems.org/gems/vuejs-rails)
 5 | 
 6 | ### About
 7 | 
 8 | Rails 3.1+ asset-pipeline gem to provide Vue.js
 9 | 
10 | ### Package Versions
11 | 
12 | - vue v2.5.13
13 | - vue-router v3.0.1
14 | - vue-resource v1.3.5
15 | - vuex v3.0.1
16 | 
17 | ### Compatibility
18 | 
19 | - vue-router v3.0.0 has breaking changes for TypeScript: https://github.com/vuejs/vue-router/releases/tag/v3.0.0
20 | - vuex v3.0.0 has breaking changes for TypeScript: https://github.com/vuejs/vuex/releases/tag/v3.0.0
21 | 
22 | ### Setup
23 | 
24 | Have in your Gemfile:
25 | 
26 | ```ruby
27 | gem 'vuejs-rails'
28 | ```
29 | 
30 | And in your application.js manifest:
31 | 
32 | ```js
33 | //= require vue
34 | //= require vue-router (optional)
35 | //= require vue-resource (optional)
36 | //= require vuex (optional)
37 | ```
38 | 
39 | If your `application.js` requires TurboLinks (a default setting for new Rails apps), you should strongly consider disabling it, as it will cause pages to load without reloading the Javascript.
40 | 
41 | In `app/views/layouts/application.html.erb`, move this line from the head of the document to the end of the body:
42 | 
43 | ```html
44 | <%= javascript_include_tag 'application' %>
45 | ```
46 | 
47 | You may write your Vue.js code directly in your views using `<script>` tags, or in a separate Javascript file (recommended).
48 | 
49 | #### Full and minified assets versions
50 | 
51 | Starting from version '>= 2.3.2', by default, gem uses minified versions in production and full versions otherwise.
52 | 
53 | You can override this behavior by setting `Vue.development_mode` flag:
54 | ```ruby
55 | Vue.development_mode = true
56 | ```
57 | You can do it in e.g. `config/initializers/vue_config.rb`, your environment initializers.
58 | 
59 | Make sure to clean your assets cache (`rake tmp:cache:clear`) after changing state of the flag.
60 | 
61 | ## Contributing
62 | 
63 | Contributions are welcome, please follow [GitHub Flow](https://guides.github.com/introduction/flow/index.html)
64 | 
65 | ## License
66 | 
67 | [MIT](LICENSE.md)
68 | 


--------------------------------------------------------------------------------
/lib/vuejs-rails.rb:
--------------------------------------------------------------------------------
 1 | require "vuejs-rails/version"
 2 | 
 3 | module Vue
 4 |   mattr_accessor :development_mode
 5 |   self.development_mode = defined?(::Rails) && ::Rails.env.development?
 6 | 
 7 |   class << self
 8 |     def full_or_minified(asset_name)
 9 |       development_mode ? "dist/#{asset_name}.js": "dist/#{asset_name}.min.js"
10 |     end
11 |   end
12 | 
13 |   module Rails
14 |     require "vuejs-rails/engine" if defined?(::Rails) and Gem::Requirement.new('>= 3.1').satisfied_by?(Gem::Version.new ::Rails.version)
15 |   end
16 | end
17 | 


--------------------------------------------------------------------------------
/lib/vuejs-rails/engine.rb:
--------------------------------------------------------------------------------
1 | module Vue
2 |   module Rails
3 |     class Engine < ::Rails::Engine
4 |     end
5 |   end
6 | end
7 | 


--------------------------------------------------------------------------------
/lib/vuejs-rails/version.rb:
--------------------------------------------------------------------------------
1 | module Vue
2 |   module Rails
3 |     VERSION = '2.5.13'
4 |   end
5 | end
6 | 


--------------------------------------------------------------------------------
/vendor/assets/javascripts/dist/vue-resource.js:
--------------------------------------------------------------------------------
   1 | /*!
   2 |  * vue-resource v1.3.5
   3 |  * https://github.com/pagekit/vue-resource
   4 |  * Released under the MIT License.
   5 |  */
   6 | 
   7 | (function (global, factory) {
   8 | 	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   9 | 	typeof define === 'function' && define.amd ? define(factory) :
  10 | 	(global.VueResource = factory());
  11 | }(this, (function () { 'use strict';
  12 | 
  13 | /**
  14 |  * Promises/A+ polyfill v1.1.4 (https://github.com/bramstein/promis)
  15 |  */
  16 | 
  17 | var RESOLVED = 0;
  18 | var REJECTED = 1;
  19 | var PENDING  = 2;
  20 | 
  21 | function Promise$1(executor) {
  22 | 
  23 |     this.state = PENDING;
  24 |     this.value = undefined;
  25 |     this.deferred = [];
  26 | 
  27 |     var promise = this;
  28 | 
  29 |     try {
  30 |         executor(function (x) {
  31 |             promise.resolve(x);
  32 |         }, function (r) {
  33 |             promise.reject(r);
  34 |         });
  35 |     } catch (e) {
  36 |         promise.reject(e);
  37 |     }
  38 | }
  39 | 
  40 | Promise$1.reject = function (r) {
  41 |     return new Promise$1(function (resolve, reject) {
  42 |         reject(r);
  43 |     });
  44 | };
  45 | 
  46 | Promise$1.resolve = function (x) {
  47 |     return new Promise$1(function (resolve, reject) {
  48 |         resolve(x);
  49 |     });
  50 | };
  51 | 
  52 | Promise$1.all = function all(iterable) {
  53 |     return new Promise$1(function (resolve, reject) {
  54 |         var count = 0, result = [];
  55 | 
  56 |         if (iterable.length === 0) {
  57 |             resolve(result);
  58 |         }
  59 | 
  60 |         function resolver(i) {
  61 |             return function (x) {
  62 |                 result[i] = x;
  63 |                 count += 1;
  64 | 
  65 |                 if (count === iterable.length) {
  66 |                     resolve(result);
  67 |                 }
  68 |             };
  69 |         }
  70 | 
  71 |         for (var i = 0; i < iterable.length; i += 1) {
  72 |             Promise$1.resolve(iterable[i]).then(resolver(i), reject);
  73 |         }
  74 |     });
  75 | };
  76 | 
  77 | Promise$1.race = function race(iterable) {
  78 |     return new Promise$1(function (resolve, reject) {
  79 |         for (var i = 0; i < iterable.length; i += 1) {
  80 |             Promise$1.resolve(iterable[i]).then(resolve, reject);
  81 |         }
  82 |     });
  83 | };
  84 | 
  85 | var p$1 = Promise$1.prototype;
  86 | 
  87 | p$1.resolve = function resolve(x) {
  88 |     var promise = this;
  89 | 
  90 |     if (promise.state === PENDING) {
  91 |         if (x === promise) {
  92 |             throw new TypeError('Promise settled with itself.');
  93 |         }
  94 | 
  95 |         var called = false;
  96 | 
  97 |         try {
  98 |             var then = x && x['then'];
  99 | 
 100 |             if (x !== null && typeof x === 'object' && typeof then === 'function') {
 101 |                 then.call(x, function (x) {
 102 |                     if (!called) {
 103 |                         promise.resolve(x);
 104 |                     }
 105 |                     called = true;
 106 | 
 107 |                 }, function (r) {
 108 |                     if (!called) {
 109 |                         promise.reject(r);
 110 |                     }
 111 |                     called = true;
 112 |                 });
 113 |                 return;
 114 |             }
 115 |         } catch (e) {
 116 |             if (!called) {
 117 |                 promise.reject(e);
 118 |             }
 119 |             return;
 120 |         }
 121 | 
 122 |         promise.state = RESOLVED;
 123 |         promise.value = x;
 124 |         promise.notify();
 125 |     }
 126 | };
 127 | 
 128 | p$1.reject = function reject(reason) {
 129 |     var promise = this;
 130 | 
 131 |     if (promise.state === PENDING) {
 132 |         if (reason === promise) {
 133 |             throw new TypeError('Promise settled with itself.');
 134 |         }
 135 | 
 136 |         promise.state = REJECTED;
 137 |         promise.value = reason;
 138 |         promise.notify();
 139 |     }
 140 | };
 141 | 
 142 | p$1.notify = function notify() {
 143 |     var promise = this;
 144 | 
 145 |     nextTick(function () {
 146 |         if (promise.state !== PENDING) {
 147 |             while (promise.deferred.length) {
 148 |                 var deferred = promise.deferred.shift(),
 149 |                     onResolved = deferred[0],
 150 |                     onRejected = deferred[1],
 151 |                     resolve = deferred[2],
 152 |                     reject = deferred[3];
 153 | 
 154 |                 try {
 155 |                     if (promise.state === RESOLVED) {
 156 |                         if (typeof onResolved === 'function') {
 157 |                             resolve(onResolved.call(undefined, promise.value));
 158 |                         } else {
 159 |                             resolve(promise.value);
 160 |                         }
 161 |                     } else if (promise.state === REJECTED) {
 162 |                         if (typeof onRejected === 'function') {
 163 |                             resolve(onRejected.call(undefined, promise.value));
 164 |                         } else {
 165 |                             reject(promise.value);
 166 |                         }
 167 |                     }
 168 |                 } catch (e) {
 169 |                     reject(e);
 170 |                 }
 171 |             }
 172 |         }
 173 |     });
 174 | };
 175 | 
 176 | p$1.then = function then(onResolved, onRejected) {
 177 |     var promise = this;
 178 | 
 179 |     return new Promise$1(function (resolve, reject) {
 180 |         promise.deferred.push([onResolved, onRejected, resolve, reject]);
 181 |         promise.notify();
 182 |     });
 183 | };
 184 | 
 185 | p$1.catch = function (onRejected) {
 186 |     return this.then(undefined, onRejected);
 187 | };
 188 | 
 189 | /**
 190 |  * Promise adapter.
 191 |  */
 192 | 
 193 | if (typeof Promise === 'undefined') {
 194 |     window.Promise = Promise$1;
 195 | }
 196 | 
 197 | function PromiseObj(executor, context) {
 198 | 
 199 |     if (executor instanceof Promise) {
 200 |         this.promise = executor;
 201 |     } else {
 202 |         this.promise = new Promise(executor.bind(context));
 203 |     }
 204 | 
 205 |     this.context = context;
 206 | }
 207 | 
 208 | PromiseObj.all = function (iterable, context) {
 209 |     return new PromiseObj(Promise.all(iterable), context);
 210 | };
 211 | 
 212 | PromiseObj.resolve = function (value, context) {
 213 |     return new PromiseObj(Promise.resolve(value), context);
 214 | };
 215 | 
 216 | PromiseObj.reject = function (reason, context) {
 217 |     return new PromiseObj(Promise.reject(reason), context);
 218 | };
 219 | 
 220 | PromiseObj.race = function (iterable, context) {
 221 |     return new PromiseObj(Promise.race(iterable), context);
 222 | };
 223 | 
 224 | var p = PromiseObj.prototype;
 225 | 
 226 | p.bind = function (context) {
 227 |     this.context = context;
 228 |     return this;
 229 | };
 230 | 
 231 | p.then = function (fulfilled, rejected) {
 232 | 
 233 |     if (fulfilled && fulfilled.bind && this.context) {
 234 |         fulfilled = fulfilled.bind(this.context);
 235 |     }
 236 | 
 237 |     if (rejected && rejected.bind && this.context) {
 238 |         rejected = rejected.bind(this.context);
 239 |     }
 240 | 
 241 |     return new PromiseObj(this.promise.then(fulfilled, rejected), this.context);
 242 | };
 243 | 
 244 | p.catch = function (rejected) {
 245 | 
 246 |     if (rejected && rejected.bind && this.context) {
 247 |         rejected = rejected.bind(this.context);
 248 |     }
 249 | 
 250 |     return new PromiseObj(this.promise.catch(rejected), this.context);
 251 | };
 252 | 
 253 | p.finally = function (callback) {
 254 | 
 255 |     return this.then(function (value) {
 256 |             callback.call(this);
 257 |             return value;
 258 |         }, function (reason) {
 259 |             callback.call(this);
 260 |             return Promise.reject(reason);
 261 |         }
 262 |     );
 263 | };
 264 | 
 265 | /**
 266 |  * Utility functions.
 267 |  */
 268 | 
 269 | var ref = {};
 270 | var hasOwnProperty = ref.hasOwnProperty;
 271 | 
 272 | var ref$1 = [];
 273 | var slice = ref$1.slice;
 274 | var debug = false;
 275 | var ntick;
 276 | 
 277 | var inBrowser = typeof window !== 'undefined';
 278 | 
 279 | function Util (ref) {
 280 |     var config = ref.config;
 281 |     var nextTick = ref.nextTick;
 282 | 
 283 |     ntick = nextTick;
 284 |     debug = config.debug || !config.silent;
 285 | }
 286 | 
 287 | function warn(msg) {
 288 |     if (typeof console !== 'undefined' && debug) {
 289 |         console.warn('[VueResource warn]: ' + msg);
 290 |     }
 291 | }
 292 | 
 293 | function error(msg) {
 294 |     if (typeof console !== 'undefined') {
 295 |         console.error(msg);
 296 |     }
 297 | }
 298 | 
 299 | function nextTick(cb, ctx) {
 300 |     return ntick(cb, ctx);
 301 | }
 302 | 
 303 | function trim(str) {
 304 |     return str ? str.replace(/^\s*|\s*$/g, '') : '';
 305 | }
 306 | 
 307 | function trimEnd(str, chars) {
 308 | 
 309 |     if (str && chars === undefined) {
 310 |         return str.replace(/\s+$/, '');
 311 |     }
 312 | 
 313 |     if (!str || !chars) {
 314 |         return str;
 315 |     }
 316 | 
 317 |     return str.replace(new RegExp(("[" + chars + "]+$")), '');
 318 | }
 319 | 
 320 | function toLower(str) {
 321 |     return str ? str.toLowerCase() : '';
 322 | }
 323 | 
 324 | function toUpper(str) {
 325 |     return str ? str.toUpperCase() : '';
 326 | }
 327 | 
 328 | var isArray = Array.isArray;
 329 | 
 330 | function isString(val) {
 331 |     return typeof val === 'string';
 332 | }
 333 | 
 334 | 
 335 | 
 336 | function isFunction(val) {
 337 |     return typeof val === 'function';
 338 | }
 339 | 
 340 | function isObject(obj) {
 341 |     return obj !== null && typeof obj === 'object';
 342 | }
 343 | 
 344 | function isPlainObject(obj) {
 345 |     return isObject(obj) && Object.getPrototypeOf(obj) == Object.prototype;
 346 | }
 347 | 
 348 | function isBlob(obj) {
 349 |     return typeof Blob !== 'undefined' && obj instanceof Blob;
 350 | }
 351 | 
 352 | function isFormData(obj) {
 353 |     return typeof FormData !== 'undefined' && obj instanceof FormData;
 354 | }
 355 | 
 356 | function when(value, fulfilled, rejected) {
 357 | 
 358 |     var promise = PromiseObj.resolve(value);
 359 | 
 360 |     if (arguments.length < 2) {
 361 |         return promise;
 362 |     }
 363 | 
 364 |     return promise.then(fulfilled, rejected);
 365 | }
 366 | 
 367 | function options(fn, obj, opts) {
 368 | 
 369 |     opts = opts || {};
 370 | 
 371 |     if (isFunction(opts)) {
 372 |         opts = opts.call(obj);
 373 |     }
 374 | 
 375 |     return merge(fn.bind({$vm: obj, $options: opts}), fn, {$options: opts});
 376 | }
 377 | 
 378 | function each(obj, iterator) {
 379 | 
 380 |     var i, key;
 381 | 
 382 |     if (isArray(obj)) {
 383 |         for (i = 0; i < obj.length; i++) {
 384 |             iterator.call(obj[i], obj[i], i);
 385 |         }
 386 |     } else if (isObject(obj)) {
 387 |         for (key in obj) {
 388 |             if (hasOwnProperty.call(obj, key)) {
 389 |                 iterator.call(obj[key], obj[key], key);
 390 |             }
 391 |         }
 392 |     }
 393 | 
 394 |     return obj;
 395 | }
 396 | 
 397 | var assign = Object.assign || _assign;
 398 | 
 399 | function merge(target) {
 400 | 
 401 |     var args = slice.call(arguments, 1);
 402 | 
 403 |     args.forEach(function (source) {
 404 |         _merge(target, source, true);
 405 |     });
 406 | 
 407 |     return target;
 408 | }
 409 | 
 410 | function defaults(target) {
 411 | 
 412 |     var args = slice.call(arguments, 1);
 413 | 
 414 |     args.forEach(function (source) {
 415 | 
 416 |         for (var key in source) {
 417 |             if (target[key] === undefined) {
 418 |                 target[key] = source[key];
 419 |             }
 420 |         }
 421 | 
 422 |     });
 423 | 
 424 |     return target;
 425 | }
 426 | 
 427 | function _assign(target) {
 428 | 
 429 |     var args = slice.call(arguments, 1);
 430 | 
 431 |     args.forEach(function (source) {
 432 |         _merge(target, source);
 433 |     });
 434 | 
 435 |     return target;
 436 | }
 437 | 
 438 | function _merge(target, source, deep) {
 439 |     for (var key in source) {
 440 |         if (deep && (isPlainObject(source[key]) || isArray(source[key]))) {
 441 |             if (isPlainObject(source[key]) && !isPlainObject(target[key])) {
 442 |                 target[key] = {};
 443 |             }
 444 |             if (isArray(source[key]) && !isArray(target[key])) {
 445 |                 target[key] = [];
 446 |             }
 447 |             _merge(target[key], source[key], deep);
 448 |         } else if (source[key] !== undefined) {
 449 |             target[key] = source[key];
 450 |         }
 451 |     }
 452 | }
 453 | 
 454 | /**
 455 |  * Root Prefix Transform.
 456 |  */
 457 | 
 458 | function root (options$$1, next) {
 459 | 
 460 |     var url = next(options$$1);
 461 | 
 462 |     if (isString(options$$1.root) && !/^(https?:)?\//.test(url)) {
 463 |         url = trimEnd(options$$1.root, '/') + '/' + url;
 464 |     }
 465 | 
 466 |     return url;
 467 | }
 468 | 
 469 | /**
 470 |  * Query Parameter Transform.
 471 |  */
 472 | 
 473 | function query (options$$1, next) {
 474 | 
 475 |     var urlParams = Object.keys(Url.options.params), query = {}, url = next(options$$1);
 476 | 
 477 |     each(options$$1.params, function (value, key) {
 478 |         if (urlParams.indexOf(key) === -1) {
 479 |             query[key] = value;
 480 |         }
 481 |     });
 482 | 
 483 |     query = Url.params(query);
 484 | 
 485 |     if (query) {
 486 |         url += (url.indexOf('?') == -1 ? '?' : '&') + query;
 487 |     }
 488 | 
 489 |     return url;
 490 | }
 491 | 
 492 | /**
 493 |  * URL Template v2.0.6 (https://github.com/bramstein/url-template)
 494 |  */
 495 | 
 496 | function expand(url, params, variables) {
 497 | 
 498 |     var tmpl = parse(url), expanded = tmpl.expand(params);
 499 | 
 500 |     if (variables) {
 501 |         variables.push.apply(variables, tmpl.vars);
 502 |     }
 503 | 
 504 |     return expanded;
 505 | }
 506 | 
 507 | function parse(template) {
 508 | 
 509 |     var operators = ['+', '#', '.', '/', ';', '?', '&'], variables = [];
 510 | 
 511 |     return {
 512 |         vars: variables,
 513 |         expand: function expand(context) {
 514 |             return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) {
 515 |                 if (expression) {
 516 | 
 517 |                     var operator = null, values = [];
 518 | 
 519 |                     if (operators.indexOf(expression.charAt(0)) !== -1) {
 520 |                         operator = expression.charAt(0);
 521 |                         expression = expression.substr(1);
 522 |                     }
 523 | 
 524 |                     expression.split(/,/g).forEach(function (variable) {
 525 |                         var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
 526 |                         values.push.apply(values, getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
 527 |                         variables.push(tmp[1]);
 528 |                     });
 529 | 
 530 |                     if (operator && operator !== '+') {
 531 | 
 532 |                         var separator = ',';
 533 | 
 534 |                         if (operator === '?') {
 535 |                             separator = '&';
 536 |                         } else if (operator !== '#') {
 537 |                             separator = operator;
 538 |                         }
 539 | 
 540 |                         return (values.length !== 0 ? operator : '') + values.join(separator);
 541 |                     } else {
 542 |                         return values.join(',');
 543 |                     }
 544 | 
 545 |                 } else {
 546 |                     return encodeReserved(literal);
 547 |                 }
 548 |             });
 549 |         }
 550 |     };
 551 | }
 552 | 
 553 | function getValues(context, operator, key, modifier) {
 554 | 
 555 |     var value = context[key], result = [];
 556 | 
 557 |     if (isDefined(value) && value !== '') {
 558 |         if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
 559 |             value = value.toString();
 560 | 
 561 |             if (modifier && modifier !== '*') {
 562 |                 value = value.substring(0, parseInt(modifier, 10));
 563 |             }
 564 | 
 565 |             result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : null));
 566 |         } else {
 567 |             if (modifier === '*') {
 568 |                 if (Array.isArray(value)) {
 569 |                     value.filter(isDefined).forEach(function (value) {
 570 |                         result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : null));
 571 |                     });
 572 |                 } else {
 573 |                     Object.keys(value).forEach(function (k) {
 574 |                         if (isDefined(value[k])) {
 575 |                             result.push(encodeValue(operator, value[k], k));
 576 |                         }
 577 |                     });
 578 |                 }
 579 |             } else {
 580 |                 var tmp = [];
 581 | 
 582 |                 if (Array.isArray(value)) {
 583 |                     value.filter(isDefined).forEach(function (value) {
 584 |                         tmp.push(encodeValue(operator, value));
 585 |                     });
 586 |                 } else {
 587 |                     Object.keys(value).forEach(function (k) {
 588 |                         if (isDefined(value[k])) {
 589 |                             tmp.push(encodeURIComponent(k));
 590 |                             tmp.push(encodeValue(operator, value[k].toString()));
 591 |                         }
 592 |                     });
 593 |                 }
 594 | 
 595 |                 if (isKeyOperator(operator)) {
 596 |                     result.push(encodeURIComponent(key) + '=' + tmp.join(','));
 597 |                 } else if (tmp.length !== 0) {
 598 |                     result.push(tmp.join(','));
 599 |                 }
 600 |             }
 601 |         }
 602 |     } else {
 603 |         if (operator === ';') {
 604 |             result.push(encodeURIComponent(key));
 605 |         } else if (value === '' && (operator === '&' || operator === '?')) {
 606 |             result.push(encodeURIComponent(key) + '=');
 607 |         } else if (value === '') {
 608 |             result.push('');
 609 |         }
 610 |     }
 611 | 
 612 |     return result;
 613 | }
 614 | 
 615 | function isDefined(value) {
 616 |     return value !== undefined && value !== null;
 617 | }
 618 | 
 619 | function isKeyOperator(operator) {
 620 |     return operator === ';' || operator === '&' || operator === '?';
 621 | }
 622 | 
 623 | function encodeValue(operator, value, key) {
 624 | 
 625 |     value = (operator === '+' || operator === '#') ? encodeReserved(value) : encodeURIComponent(value);
 626 | 
 627 |     if (key) {
 628 |         return encodeURIComponent(key) + '=' + value;
 629 |     } else {
 630 |         return value;
 631 |     }
 632 | }
 633 | 
 634 | function encodeReserved(str) {
 635 |     return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) {
 636 |         if (!/%[0-9A-Fa-f]/.test(part)) {
 637 |             part = encodeURI(part);
 638 |         }
 639 |         return part;
 640 |     }).join('');
 641 | }
 642 | 
 643 | /**
 644 |  * URL Template (RFC 6570) Transform.
 645 |  */
 646 | 
 647 | function template (options) {
 648 | 
 649 |     var variables = [], url = expand(options.url, options.params, variables);
 650 | 
 651 |     variables.forEach(function (key) {
 652 |         delete options.params[key];
 653 |     });
 654 | 
 655 |     return url;
 656 | }
 657 | 
 658 | /**
 659 |  * Service for URL templating.
 660 |  */
 661 | 
 662 | function Url(url, params) {
 663 | 
 664 |     var self = this || {}, options$$1 = url, transform;
 665 | 
 666 |     if (isString(url)) {
 667 |         options$$1 = {url: url, params: params};
 668 |     }
 669 | 
 670 |     options$$1 = merge({}, Url.options, self.$options, options$$1);
 671 | 
 672 |     Url.transforms.forEach(function (handler) {
 673 | 
 674 |         if (isString(handler)) {
 675 |             handler = Url.transform[handler];
 676 |         }
 677 | 
 678 |         if (isFunction(handler)) {
 679 |             transform = factory(handler, transform, self.$vm);
 680 |         }
 681 | 
 682 |     });
 683 | 
 684 |     return transform(options$$1);
 685 | }
 686 | 
 687 | /**
 688 |  * Url options.
 689 |  */
 690 | 
 691 | Url.options = {
 692 |     url: '',
 693 |     root: null,
 694 |     params: {}
 695 | };
 696 | 
 697 | /**
 698 |  * Url transforms.
 699 |  */
 700 | 
 701 | Url.transform = {template: template, query: query, root: root};
 702 | Url.transforms = ['template', 'query', 'root'];
 703 | 
 704 | /**
 705 |  * Encodes a Url parameter string.
 706 |  *
 707 |  * @param {Object} obj
 708 |  */
 709 | 
 710 | Url.params = function (obj) {
 711 | 
 712 |     var params = [], escape = encodeURIComponent;
 713 | 
 714 |     params.add = function (key, value) {
 715 | 
 716 |         if (isFunction(value)) {
 717 |             value = value();
 718 |         }
 719 | 
 720 |         if (value === null) {
 721 |             value = '';
 722 |         }
 723 | 
 724 |         this.push(escape(key) + '=' + escape(value));
 725 |     };
 726 | 
 727 |     serialize(params, obj);
 728 | 
 729 |     return params.join('&').replace(/%20/g, '+');
 730 | };
 731 | 
 732 | /**
 733 |  * Parse a URL and return its components.
 734 |  *
 735 |  * @param {String} url
 736 |  */
 737 | 
 738 | Url.parse = function (url) {
 739 | 
 740 |     var el = document.createElement('a');
 741 | 
 742 |     if (document.documentMode) {
 743 |         el.href = url;
 744 |         url = el.href;
 745 |     }
 746 | 
 747 |     el.href = url;
 748 | 
 749 |     return {
 750 |         href: el.href,
 751 |         protocol: el.protocol ? el.protocol.replace(/:$/, '') : '',
 752 |         port: el.port,
 753 |         host: el.host,
 754 |         hostname: el.hostname,
 755 |         pathname: el.pathname.charAt(0) === '/' ? el.pathname : '/' + el.pathname,
 756 |         search: el.search ? el.search.replace(/^\?/, '') : '',
 757 |         hash: el.hash ? el.hash.replace(/^#/, '') : ''
 758 |     };
 759 | };
 760 | 
 761 | function factory(handler, next, vm) {
 762 |     return function (options$$1) {
 763 |         return handler.call(vm, options$$1, next);
 764 |     };
 765 | }
 766 | 
 767 | function serialize(params, obj, scope) {
 768 | 
 769 |     var array = isArray(obj), plain = isPlainObject(obj), hash;
 770 | 
 771 |     each(obj, function (value, key) {
 772 | 
 773 |         hash = isObject(value) || isArray(value);
 774 | 
 775 |         if (scope) {
 776 |             key = scope + '[' + (plain || hash ? key : '') + ']';
 777 |         }
 778 | 
 779 |         if (!scope && array) {
 780 |             params.add(value.name, value.value);
 781 |         } else if (hash) {
 782 |             serialize(params, value, key);
 783 |         } else {
 784 |             params.add(key, value);
 785 |         }
 786 |     });
 787 | }
 788 | 
 789 | /**
 790 |  * XDomain client (Internet Explorer).
 791 |  */
 792 | 
 793 | function xdrClient (request) {
 794 |     return new PromiseObj(function (resolve) {
 795 | 
 796 |         var xdr = new XDomainRequest(), handler = function (ref) {
 797 |             var type = ref.type;
 798 | 
 799 | 
 800 |             var status = 0;
 801 | 
 802 |             if (type === 'load') {
 803 |                 status = 200;
 804 |             } else if (type === 'error') {
 805 |                 status = 500;
 806 |             }
 807 | 
 808 |             resolve(request.respondWith(xdr.responseText, {status: status}));
 809 |         };
 810 | 
 811 |         request.abort = function () { return xdr.abort(); };
 812 | 
 813 |         xdr.open(request.method, request.getUrl());
 814 | 
 815 |         if (request.timeout) {
 816 |             xdr.timeout = request.timeout;
 817 |         }
 818 | 
 819 |         xdr.onload = handler;
 820 |         xdr.onabort = handler;
 821 |         xdr.onerror = handler;
 822 |         xdr.ontimeout = handler;
 823 |         xdr.onprogress = function () {};
 824 |         xdr.send(request.getBody());
 825 |     });
 826 | }
 827 | 
 828 | /**
 829 |  * CORS Interceptor.
 830 |  */
 831 | 
 832 | var SUPPORTS_CORS = inBrowser && 'withCredentials' in new XMLHttpRequest();
 833 | 
 834 | function cors (request, next) {
 835 | 
 836 |     if (inBrowser) {
 837 | 
 838 |         var orgUrl = Url.parse(location.href);
 839 |         var reqUrl = Url.parse(request.getUrl());
 840 | 
 841 |         if (reqUrl.protocol !== orgUrl.protocol || reqUrl.host !== orgUrl.host) {
 842 | 
 843 |             request.crossOrigin = true;
 844 |             request.emulateHTTP = false;
 845 | 
 846 |             if (!SUPPORTS_CORS) {
 847 |                 request.client = xdrClient;
 848 |             }
 849 |         }
 850 |     }
 851 | 
 852 |     next();
 853 | }
 854 | 
 855 | /**
 856 |  * Form data Interceptor.
 857 |  */
 858 | 
 859 | function form (request, next) {
 860 | 
 861 |     if (isFormData(request.body)) {
 862 | 
 863 |         request.headers.delete('Content-Type');
 864 | 
 865 |     } else if (isObject(request.body) && request.emulateJSON) {
 866 | 
 867 |         request.body = Url.params(request.body);
 868 |         request.headers.set('Content-Type', 'application/x-www-form-urlencoded');
 869 |     }
 870 | 
 871 |     next();
 872 | }
 873 | 
 874 | /**
 875 |  * JSON Interceptor.
 876 |  */
 877 | 
 878 | function json (request, next) {
 879 | 
 880 |     var type = request.headers.get('Content-Type') || '';
 881 | 
 882 |     if (isObject(request.body) && type.indexOf('application/json') === 0) {
 883 |         request.body = JSON.stringify(request.body);
 884 |     }
 885 | 
 886 |     next(function (response) {
 887 | 
 888 |         return response.bodyText ? when(response.text(), function (text) {
 889 | 
 890 |             type = response.headers.get('Content-Type') || '';
 891 | 
 892 |             if (type.indexOf('application/json') === 0 || isJson(text)) {
 893 | 
 894 |                 try {
 895 |                     response.body = JSON.parse(text);
 896 |                 } catch (e) {
 897 |                     response.body = null;
 898 |                 }
 899 | 
 900 |             } else {
 901 |                 response.body = text;
 902 |             }
 903 | 
 904 |             return response;
 905 | 
 906 |         }) : response;
 907 | 
 908 |     });
 909 | }
 910 | 
 911 | function isJson(str) {
 912 | 
 913 |     var start = str.match(/^\s*(\[|\{)/);
 914 |     var end = {'[': /]\s*$/, '{': /}\s*$/};
 915 | 
 916 |     return start && end[start[1]].test(str);
 917 | }
 918 | 
 919 | /**
 920 |  * JSONP client (Browser).
 921 |  */
 922 | 
 923 | function jsonpClient (request) {
 924 |     return new PromiseObj(function (resolve) {
 925 | 
 926 |         var name = request.jsonp || 'callback', callback = request.jsonpCallback || '_jsonp' + Math.random().toString(36).substr(2), body = null, handler, script;
 927 | 
 928 |         handler = function (ref) {
 929 |             var type = ref.type;
 930 | 
 931 | 
 932 |             var status = 0;
 933 | 
 934 |             if (type === 'load' && body !== null) {
 935 |                 status = 200;
 936 |             } else if (type === 'error') {
 937 |                 status = 500;
 938 |             }
 939 | 
 940 |             if (status && window[callback]) {
 941 |                 delete window[callback];
 942 |                 document.body.removeChild(script);
 943 |             }
 944 | 
 945 |             resolve(request.respondWith(body, {status: status}));
 946 |         };
 947 | 
 948 |         window[callback] = function (result) {
 949 |             body = JSON.stringify(result);
 950 |         };
 951 | 
 952 |         request.abort = function () {
 953 |             handler({type: 'abort'});
 954 |         };
 955 | 
 956 |         request.params[name] = callback;
 957 | 
 958 |         if (request.timeout) {
 959 |             setTimeout(request.abort, request.timeout);
 960 |         }
 961 | 
 962 |         script = document.createElement('script');
 963 |         script.src = request.getUrl();
 964 |         script.type = 'text/javascript';
 965 |         script.async = true;
 966 |         script.onload = handler;
 967 |         script.onerror = handler;
 968 | 
 969 |         document.body.appendChild(script);
 970 |     });
 971 | }
 972 | 
 973 | /**
 974 |  * JSONP Interceptor.
 975 |  */
 976 | 
 977 | function jsonp (request, next) {
 978 | 
 979 |     if (request.method == 'JSONP') {
 980 |         request.client = jsonpClient;
 981 |     }
 982 | 
 983 |     next();
 984 | }
 985 | 
 986 | /**
 987 |  * Before Interceptor.
 988 |  */
 989 | 
 990 | function before (request, next) {
 991 | 
 992 |     if (isFunction(request.before)) {
 993 |         request.before.call(this, request);
 994 |     }
 995 | 
 996 |     next();
 997 | }
 998 | 
 999 | /**
1000 |  * HTTP method override Interceptor.
1001 |  */
1002 | 
1003 | function method (request, next) {
1004 | 
1005 |     if (request.emulateHTTP && /^(PUT|PATCH|DELETE)$/i.test(request.method)) {
1006 |         request.headers.set('X-HTTP-Method-Override', request.method);
1007 |         request.method = 'POST';
1008 |     }
1009 | 
1010 |     next();
1011 | }
1012 | 
1013 | /**
1014 |  * Header Interceptor.
1015 |  */
1016 | 
1017 | function header (request, next) {
1018 | 
1019 |     var headers = assign({}, Http.headers.common,
1020 |         !request.crossOrigin ? Http.headers.custom : {},
1021 |         Http.headers[toLower(request.method)]
1022 |     );
1023 | 
1024 |     each(headers, function (value, name) {
1025 |         if (!request.headers.has(name)) {
1026 |             request.headers.set(name, value);
1027 |         }
1028 |     });
1029 | 
1030 |     next();
1031 | }
1032 | 
1033 | /**
1034 |  * XMLHttp client (Browser).
1035 |  */
1036 | 
1037 | function xhrClient (request) {
1038 |     return new PromiseObj(function (resolve) {
1039 | 
1040 |         var xhr = new XMLHttpRequest(), handler = function (event) {
1041 | 
1042 |             var response = request.respondWith(
1043 |                 'response' in xhr ? xhr.response : xhr.responseText, {
1044 |                     status: xhr.status === 1223 ? 204 : xhr.status, // IE9 status bug
1045 |                     statusText: xhr.status === 1223 ? 'No Content' : trim(xhr.statusText)
1046 |                 }
1047 |             );
1048 | 
1049 |             each(trim(xhr.getAllResponseHeaders()).split('\n'), function (row) {
1050 |                 response.headers.append(row.slice(0, row.indexOf(':')), row.slice(row.indexOf(':') + 1));
1051 |             });
1052 | 
1053 |             resolve(response);
1054 |         };
1055 | 
1056 |         request.abort = function () { return xhr.abort(); };
1057 | 
1058 |         if (request.progress) {
1059 |             if (request.method === 'GET') {
1060 |                 xhr.addEventListener('progress', request.progress);
1061 |             } else if (/^(POST|PUT)$/i.test(request.method)) {
1062 |                 xhr.upload.addEventListener('progress', request.progress);
1063 |             }
1064 |         }
1065 | 
1066 |         xhr.open(request.method, request.getUrl(), true);
1067 | 
1068 |         if (request.timeout) {
1069 |             xhr.timeout = request.timeout;
1070 |         }
1071 | 
1072 |         if (request.responseType && 'responseType' in xhr) {
1073 |             xhr.responseType = request.responseType;
1074 |         }
1075 | 
1076 |         if (request.withCredentials || request.credentials) {
1077 |             xhr.withCredentials = true;
1078 |         }
1079 | 
1080 |         if (!request.crossOrigin) {
1081 |             request.headers.set('X-Requested-With', 'XMLHttpRequest');
1082 |         }
1083 | 
1084 |         request.headers.forEach(function (value, name) {
1085 |             xhr.setRequestHeader(name, value);
1086 |         });
1087 | 
1088 |         xhr.onload = handler;
1089 |         xhr.onabort = handler;
1090 |         xhr.onerror = handler;
1091 |         xhr.ontimeout = handler;
1092 |         xhr.send(request.getBody());
1093 |     });
1094 | }
1095 | 
1096 | /**
1097 |  * Http client (Node).
1098 |  */
1099 | 
1100 | function nodeClient (request) {
1101 | 
1102 |     var client = require('got');
1103 | 
1104 |     return new PromiseObj(function (resolve) {
1105 | 
1106 |         var url = request.getUrl();
1107 |         var body = request.getBody();
1108 |         var method = request.method;
1109 |         var headers = {}, handler;
1110 | 
1111 |         request.headers.forEach(function (value, name) {
1112 |             headers[name] = value;
1113 |         });
1114 | 
1115 |         client(url, {body: body, method: method, headers: headers}).then(handler = function (resp) {
1116 | 
1117 |             var response = request.respondWith(resp.body, {
1118 |                     status: resp.statusCode,
1119 |                     statusText: trim(resp.statusMessage)
1120 |                 }
1121 |             );
1122 | 
1123 |             each(resp.headers, function (value, name) {
1124 |                 response.headers.set(name, value);
1125 |             });
1126 | 
1127 |             resolve(response);
1128 | 
1129 |         }, function (error$$1) { return handler(error$$1.response); });
1130 |     });
1131 | }
1132 | 
1133 | /**
1134 |  * Base client.
1135 |  */
1136 | 
1137 | function Client (context) {
1138 | 
1139 |     var reqHandlers = [sendRequest], resHandlers = [], handler;
1140 | 
1141 |     if (!isObject(context)) {
1142 |         context = null;
1143 |     }
1144 | 
1145 |     function Client(request) {
1146 |         return new PromiseObj(function (resolve, reject) {
1147 | 
1148 |             function exec() {
1149 | 
1150 |                 handler = reqHandlers.pop();
1151 | 
1152 |                 if (isFunction(handler)) {
1153 |                     handler.call(context, request, next);
1154 |                 } else {
1155 |                     warn(("Invalid interceptor of type " + (typeof handler) + ", must be a function"));
1156 |                     next();
1157 |                 }
1158 |             }
1159 | 
1160 |             function next(response) {
1161 | 
1162 |                 if (isFunction(response)) {
1163 | 
1164 |                     resHandlers.unshift(response);
1165 | 
1166 |                 } else if (isObject(response)) {
1167 | 
1168 |                     resHandlers.forEach(function (handler) {
1169 |                         response = when(response, function (response) {
1170 |                             return handler.call(context, response) || response;
1171 |                         }, reject);
1172 |                     });
1173 | 
1174 |                     when(response, resolve, reject);
1175 | 
1176 |                     return;
1177 |                 }
1178 | 
1179 |                 exec();
1180 |             }
1181 | 
1182 |             exec();
1183 | 
1184 |         }, context);
1185 |     }
1186 | 
1187 |     Client.use = function (handler) {
1188 |         reqHandlers.push(handler);
1189 |     };
1190 | 
1191 |     return Client;
1192 | }
1193 | 
1194 | function sendRequest(request, resolve) {
1195 | 
1196 |     var client = request.client || (inBrowser ? xhrClient : nodeClient);
1197 | 
1198 |     resolve(client(request));
1199 | }
1200 | 
1201 | /**
1202 |  * HTTP Headers.
1203 |  */
1204 | 
1205 | var Headers = function Headers(headers) {
1206 |     var this$1 = this;
1207 | 
1208 | 
1209 |     this.map = {};
1210 | 
1211 |     each(headers, function (value, name) { return this$1.append(name, value); });
1212 | };
1213 | 
1214 | Headers.prototype.has = function has (name) {
1215 |     return getName(this.map, name) !== null;
1216 | };
1217 | 
1218 | Headers.prototype.get = function get (name) {
1219 | 
1220 |     var list = this.map[getName(this.map, name)];
1221 | 
1222 |     return list ? list.join() : null;
1223 | };
1224 | 
1225 | Headers.prototype.getAll = function getAll (name) {
1226 |     return this.map[getName(this.map, name)] || [];
1227 | };
1228 | 
1229 | Headers.prototype.set = function set (name, value) {
1230 |     this.map[normalizeName(getName(this.map, name) || name)] = [trim(value)];
1231 | };
1232 | 
1233 | Headers.prototype.append = function append (name, value){
1234 | 
1235 |     var list = this.map[getName(this.map, name)];
1236 | 
1237 |     if (list) {
1238 |         list.push(trim(value));
1239 |     } else {
1240 |         this.set(name, value);
1241 |     }
1242 | };
1243 | 
1244 | Headers.prototype.delete = function delete$1 (name){
1245 |     delete this.map[getName(this.map, name)];
1246 | };
1247 | 
1248 | Headers.prototype.deleteAll = function deleteAll (){
1249 |     this.map = {};
1250 | };
1251 | 
1252 | Headers.prototype.forEach = function forEach (callback, thisArg) {
1253 |         var this$1 = this;
1254 | 
1255 |     each(this.map, function (list, name) {
1256 |         each(list, function (value) { return callback.call(thisArg, value, name, this$1); });
1257 |     });
1258 | };
1259 | 
1260 | function getName(map, name) {
1261 |     return Object.keys(map).reduce(function (prev, curr) {
1262 |         return toLower(name) === toLower(curr) ? curr : prev;
1263 |     }, null);
1264 | }
1265 | 
1266 | function normalizeName(name) {
1267 | 
1268 |     if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) {
1269 |         throw new TypeError('Invalid character in header field name');
1270 |     }
1271 | 
1272 |     return trim(name);
1273 | }
1274 | 
1275 | /**
1276 |  * HTTP Response.
1277 |  */
1278 | 
1279 | var Response = function Response(body, ref) {
1280 |     var url = ref.url;
1281 |     var headers = ref.headers;
1282 |     var status = ref.status;
1283 |     var statusText = ref.statusText;
1284 | 
1285 | 
1286 |     this.url = url;
1287 |     this.ok = status >= 200 && status < 300;
1288 |     this.status = status || 0;
1289 |     this.statusText = statusText || '';
1290 |     this.headers = new Headers(headers);
1291 |     this.body = body;
1292 | 
1293 |     if (isString(body)) {
1294 | 
1295 |         this.bodyText = body;
1296 | 
1297 |     } else if (isBlob(body)) {
1298 | 
1299 |         this.bodyBlob = body;
1300 | 
1301 |         if (isBlobText(body)) {
1302 |             this.bodyText = blobText(body);
1303 |         }
1304 |     }
1305 | };
1306 | 
1307 | Response.prototype.blob = function blob () {
1308 |     return when(this.bodyBlob);
1309 | };
1310 | 
1311 | Response.prototype.text = function text () {
1312 |     return when(this.bodyText);
1313 | };
1314 | 
1315 | Response.prototype.json = function json () {
1316 |     return when(this.text(), function (text) { return JSON.parse(text); });
1317 | };
1318 | 
1319 | Object.defineProperty(Response.prototype, 'data', {
1320 | 
1321 |     get: function get() {
1322 |         return this.body;
1323 |     },
1324 | 
1325 |     set: function set(body) {
1326 |         this.body = body;
1327 |     }
1328 | 
1329 | });
1330 | 
1331 | function blobText(body) {
1332 |     return new PromiseObj(function (resolve) {
1333 | 
1334 |         var reader = new FileReader();
1335 | 
1336 |         reader.readAsText(body);
1337 |         reader.onload = function () {
1338 |             resolve(reader.result);
1339 |         };
1340 | 
1341 |     });
1342 | }
1343 | 
1344 | function isBlobText(body) {
1345 |     return body.type.indexOf('text') === 0 || body.type.indexOf('json') !== -1;
1346 | }
1347 | 
1348 | /**
1349 |  * HTTP Request.
1350 |  */
1351 | 
1352 | var Request = function Request(options$$1) {
1353 | 
1354 |     this.body = null;
1355 |     this.params = {};
1356 | 
1357 |     assign(this, options$$1, {
1358 |         method: toUpper(options$$1.method || 'GET')
1359 |     });
1360 | 
1361 |     if (!(this.headers instanceof Headers)) {
1362 |         this.headers = new Headers(this.headers);
1363 |     }
1364 | };
1365 | 
1366 | Request.prototype.getUrl = function getUrl (){
1367 |     return Url(this);
1368 | };
1369 | 
1370 | Request.prototype.getBody = function getBody (){
1371 |     return this.body;
1372 | };
1373 | 
1374 | Request.prototype.respondWith = function respondWith (body, options$$1) {
1375 |     return new Response(body, assign(options$$1 || {}, {url: this.getUrl()}));
1376 | };
1377 | 
1378 | /**
1379 |  * Service for sending network requests.
1380 |  */
1381 | 
1382 | var COMMON_HEADERS = {'Accept': 'application/json, text/plain, */*'};
1383 | var JSON_CONTENT_TYPE = {'Content-Type': 'application/json;charset=utf-8'};
1384 | 
1385 | function Http(options$$1) {
1386 | 
1387 |     var self = this || {}, client = Client(self.$vm);
1388 | 
1389 |     defaults(options$$1 || {}, self.$options, Http.options);
1390 | 
1391 |     Http.interceptors.forEach(function (handler) {
1392 | 
1393 |         if (isString(handler)) {
1394 |             handler = Http.interceptor[handler];
1395 |         }
1396 | 
1397 |         if (isFunction(handler)) {
1398 |             client.use(handler);
1399 |         }
1400 | 
1401 |     });
1402 | 
1403 |     return client(new Request(options$$1)).then(function (response) {
1404 | 
1405 |         return response.ok ? response : PromiseObj.reject(response);
1406 | 
1407 |     }, function (response) {
1408 | 
1409 |         if (response instanceof Error) {
1410 |             error(response);
1411 |         }
1412 | 
1413 |         return PromiseObj.reject(response);
1414 |     });
1415 | }
1416 | 
1417 | Http.options = {};
1418 | 
1419 | Http.headers = {
1420 |     put: JSON_CONTENT_TYPE,
1421 |     post: JSON_CONTENT_TYPE,
1422 |     patch: JSON_CONTENT_TYPE,
1423 |     delete: JSON_CONTENT_TYPE,
1424 |     common: COMMON_HEADERS,
1425 |     custom: {}
1426 | };
1427 | 
1428 | Http.interceptor = {before: before, method: method, jsonp: jsonp, json: json, form: form, header: header, cors: cors};
1429 | Http.interceptors = ['before', 'method', 'jsonp', 'json', 'form', 'header', 'cors'];
1430 | 
1431 | ['get', 'delete', 'head', 'jsonp'].forEach(function (method$$1) {
1432 | 
1433 |     Http[method$$1] = function (url, options$$1) {
1434 |         return this(assign(options$$1 || {}, {url: url, method: method$$1}));
1435 |     };
1436 | 
1437 | });
1438 | 
1439 | ['post', 'put', 'patch'].forEach(function (method$$1) {
1440 | 
1441 |     Http[method$$1] = function (url, body, options$$1) {
1442 |         return this(assign(options$$1 || {}, {url: url, method: method$$1, body: body}));
1443 |     };
1444 | 
1445 | });
1446 | 
1447 | /**
1448 |  * Service for interacting with RESTful services.
1449 |  */
1450 | 
1451 | function Resource(url, params, actions, options$$1) {
1452 | 
1453 |     var self = this || {}, resource = {};
1454 | 
1455 |     actions = assign({},
1456 |         Resource.actions,
1457 |         actions
1458 |     );
1459 | 
1460 |     each(actions, function (action, name) {
1461 | 
1462 |         action = merge({url: url, params: assign({}, params)}, options$$1, action);
1463 | 
1464 |         resource[name] = function () {
1465 |             return (self.$http || Http)(opts(action, arguments));
1466 |         };
1467 |     });
1468 | 
1469 |     return resource;
1470 | }
1471 | 
1472 | function opts(action, args) {
1473 | 
1474 |     var options$$1 = assign({}, action), params = {}, body;
1475 | 
1476 |     switch (args.length) {
1477 | 
1478 |         case 2:
1479 | 
1480 |             params = args[0];
1481 |             body = args[1];
1482 | 
1483 |             break;
1484 | 
1485 |         case 1:
1486 | 
1487 |             if (/^(POST|PUT|PATCH)$/i.test(options$$1.method)) {
1488 |                 body = args[0];
1489 |             } else {
1490 |                 params = args[0];
1491 |             }
1492 | 
1493 |             break;
1494 | 
1495 |         case 0:
1496 | 
1497 |             break;
1498 | 
1499 |         default:
1500 | 
1501 |             throw 'Expected up to 2 arguments [params, body], got ' + args.length + ' arguments';
1502 |     }
1503 | 
1504 |     options$$1.body = body;
1505 |     options$$1.params = assign({}, options$$1.params, params);
1506 | 
1507 |     return options$$1;
1508 | }
1509 | 
1510 | Resource.actions = {
1511 | 
1512 |     get: {method: 'GET'},
1513 |     save: {method: 'POST'},
1514 |     query: {method: 'GET'},
1515 |     update: {method: 'PUT'},
1516 |     remove: {method: 'DELETE'},
1517 |     delete: {method: 'DELETE'}
1518 | 
1519 | };
1520 | 
1521 | /**
1522 |  * Install plugin.
1523 |  */
1524 | 
1525 | function plugin(Vue) {
1526 | 
1527 |     if (plugin.installed) {
1528 |         return;
1529 |     }
1530 | 
1531 |     Util(Vue);
1532 | 
1533 |     Vue.url = Url;
1534 |     Vue.http = Http;
1535 |     Vue.resource = Resource;
1536 |     Vue.Promise = PromiseObj;
1537 | 
1538 |     Object.defineProperties(Vue.prototype, {
1539 | 
1540 |         $url: {
1541 |             get: function get() {
1542 |                 return options(Vue.url, this, this.$options.url);
1543 |             }
1544 |         },
1545 | 
1546 |         $http: {
1547 |             get: function get() {
1548 |                 return options(Vue.http, this, this.$options.http);
1549 |             }
1550 |         },
1551 | 
1552 |         $resource: {
1553 |             get: function get() {
1554 |                 return Vue.resource.bind(this);
1555 |             }
1556 |         },
1557 | 
1558 |         $promise: {
1559 |             get: function get() {
1560 |                 var this$1 = this;
1561 | 
1562 |                 return function (executor) { return new Vue.Promise(executor, this$1); };
1563 |             }
1564 |         }
1565 | 
1566 |     });
1567 | }
1568 | 
1569 | if (typeof window !== 'undefined' && window.Vue) {
1570 |     window.Vue.use(plugin);
1571 | }
1572 | 
1573 | return plugin;
1574 | 
1575 | })));
1576 | 


--------------------------------------------------------------------------------
/vendor/assets/javascripts/dist/vue-resource.min.js:
--------------------------------------------------------------------------------
1 | /*!
2 |  * vue-resource v1.3.5
3 |  * https://github.com/pagekit/vue-resource
4 |  * Released under the MIT License.
5 |  */
6 | 
7 | !function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):t.VueResource=e()}(this,function(){"use strict";function t(t){this.state=$,this.value=void 0,this.deferred=[];var e=this;try{t(function(t){e.resolve(t)},function(t){e.reject(t)})}catch(t){e.reject(t)}}function e(t,e){t instanceof Promise?this.promise=t:this.promise=new Promise(t.bind(e)),this.context=e}function n(t){return t?t.replace(/^\s*|\s*$/g,""):""}function o(t){return t?t.toLowerCase():""}function r(t){return"string"==typeof t}function i(t){return"function"==typeof t}function s(t){return null!==t&&"object"==typeof t}function u(t){return s(t)&&Object.getPrototypeOf(t)==Object.prototype}function a(t,n,o){var r=e.resolve(t);return arguments.length<2?r:r.then(n,o)}function c(t,e,n){return n=n||{},i(n)&&(n=n.call(e)),p(t.bind({$vm:e,$options:n}),t,{$options:n})}function f(t,e){var n,o;if(H(t))for(n=0;n<t.length;n++)e.call(t[n],t[n],n);else if(s(t))for(o in t)S.call(t,o)&&e.call(t[o],t[o],o);return t}function p(t){return k.call(arguments,1).forEach(function(e){h(t,e,!0)}),t}function h(t,e,n){for(var o in e)n&&(u(e[o])||H(e[o]))?(u(e[o])&&!u(t[o])&&(t[o]={}),H(e[o])&&!H(t[o])&&(t[o]=[]),h(t[o],e[o],n)):void 0!==e[o]&&(t[o]=e[o])}function d(t,e,n){var o=function(t){var e=["+","#",".","/",";","?","&"],n=[];return{vars:n,expand:function(o){return t.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g,function(t,r,i){if(r){var s=null,u=[];if(-1!==e.indexOf(r.charAt(0))&&(s=r.charAt(0),r=r.substr(1)),r.split(/,/g).forEach(function(t){var e=/([^:\*]*)(?::(\d+)|(\*))?/.exec(t);u.push.apply(u,function(t,e,n,o){var r=t[n],i=[];if(l(r)&&""!==r)if("string"==typeof r||"number"==typeof r||"boolean"==typeof r)r=r.toString(),o&&"*"!==o&&(r=r.substring(0,parseInt(o,10))),i.push(y(e,r,m(e)?n:null));else if("*"===o)Array.isArray(r)?r.filter(l).forEach(function(t){i.push(y(e,t,m(e)?n:null))}):Object.keys(r).forEach(function(t){l(r[t])&&i.push(y(e,r[t],t))});else{var s=[];Array.isArray(r)?r.filter(l).forEach(function(t){s.push(y(e,t))}):Object.keys(r).forEach(function(t){l(r[t])&&(s.push(encodeURIComponent(t)),s.push(y(e,r[t].toString())))}),m(e)?i.push(encodeURIComponent(n)+"="+s.join(",")):0!==s.length&&i.push(s.join(","))}else";"===e?i.push(encodeURIComponent(n)):""!==r||"&"!==e&&"?"!==e?""===r&&i.push(""):i.push(encodeURIComponent(n)+"=");return i}(o,s,e[1],e[2]||e[3])),n.push(e[1])}),s&&"+"!==s){var a=",";return"?"===s?a="&":"#"!==s&&(a=s),(0!==u.length?s:"")+u.join(a)}return u.join(",")}return v(i)})}}}(t),r=o.expand(e);return n&&n.push.apply(n,o.vars),r}function l(t){return void 0!==t&&null!==t}function m(t){return";"===t||"&"===t||"?"===t}function y(t,e,n){return e="+"===t||"#"===t?v(e):encodeURIComponent(e),n?encodeURIComponent(n)+"="+e:e}function v(t){return t.split(/(%[0-9A-Fa-f]{2})/g).map(function(t){return/%[0-9A-Fa-f]/.test(t)||(t=encodeURI(t)),t}).join("")}function b(t,e){var n,o=this||{},s=t;return r(t)&&(s={url:t,params:e}),s=p({},b.options,o.$options,s),b.transforms.forEach(function(t){r(t)&&(t=b.transform[t]),i(t)&&(n=function(t,e,n){return function(o){return t.call(n,o,e)}}(t,n,o.$vm))}),n(s)}function g(t,e,n){var o,r=H(e),i=u(e);f(e,function(e,u){o=s(e)||H(e),n&&(u=n+"["+(i||o?u:"")+"]"),!n&&r?t.add(e.name,e.value):o?g(t,e,u):t.add(u,e)})}function w(t){return new e(function(e){var n=new XDomainRequest,o=function(o){var r=o.type,i=0;"load"===r?i=200:"error"===r&&(i=500),e(t.respondWith(n.responseText,{status:i}))};t.abort=function(){return n.abort()},n.open(t.method,t.getUrl()),t.timeout&&(n.timeout=t.timeout),n.onload=o,n.onabort=o,n.onerror=o,n.ontimeout=o,n.onprogress=function(){},n.send(t.getBody())})}function T(t){return new e(function(e){var n,o,r=t.jsonp||"callback",i=t.jsonpCallback||"_jsonp"+Math.random().toString(36).substr(2),s=null;n=function(n){var r=n.type,u=0;"load"===r&&null!==s?u=200:"error"===r&&(u=500),u&&window[i]&&(delete window[i],document.body.removeChild(o)),e(t.respondWith(s,{status:u}))},window[i]=function(t){s=JSON.stringify(t)},t.abort=function(){n({type:"abort"})},t.params[r]=i,t.timeout&&setTimeout(t.abort,t.timeout),(o=document.createElement("script")).src=t.getUrl(),o.type="text/javascript",o.async=!0,o.onload=n,o.onerror=n,document.body.appendChild(o)})}function x(t){function n(n){return new e(function(e,c){function f(){i(o=r.pop())?o.call(t,n,p):(!function(t){"undefined"!=typeof console&&I&&console.warn("[VueResource warn]: "+t)}("Invalid interceptor of type "+typeof o+", must be a function"),p())}function p(n){if(i(n))u.unshift(n);else if(s(n))return u.forEach(function(e){n=a(n,function(n){return e.call(t,n)||n},c)}),void a(n,e,c);f()}f()},t)}var o,r=[j],u=[];return s(t)||(t=null),n.use=function(t){r.push(t)},n}function j(t,o){o((t.client||(q?function(t){return new e(function(e){var o=new XMLHttpRequest,r=function(r){var i=t.respondWith("response"in o?o.response:o.responseText,{status:1223===o.status?204:o.status,statusText:1223===o.status?"No Content":n(o.statusText)});f(n(o.getAllResponseHeaders()).split("\n"),function(t){i.headers.append(t.slice(0,t.indexOf(":")),t.slice(t.indexOf(":")+1))}),e(i)};t.abort=function(){return o.abort()},t.progress&&("GET"===t.method?o.addEventListener("progress",t.progress):/^(POST|PUT)$/i.test(t.method)&&o.upload.addEventListener("progress",t.progress)),o.open(t.method,t.getUrl(),!0),t.timeout&&(o.timeout=t.timeout),t.responseType&&"responseType"in o&&(o.responseType=t.responseType),(t.withCredentials||t.credentials)&&(o.withCredentials=!0),t.crossOrigin||t.headers.set("X-Requested-With","XMLHttpRequest"),t.headers.forEach(function(t,e){o.setRequestHeader(e,t)}),o.onload=r,o.onabort=r,o.onerror=r,o.ontimeout=r,o.send(t.getBody())})}:function(t){var o=require("got");return new e(function(e){var r,i=t.getUrl(),s=t.getBody(),u=t.method,a={};t.headers.forEach(function(t,e){a[e]=t}),o(i,{body:s,method:u,headers:a}).then(r=function(o){var r=t.respondWith(o.body,{status:o.statusCode,statusText:n(o.statusMessage)});f(o.headers,function(t,e){r.headers.set(e,t)}),e(r)},function(t){return r(t.response)})})}))(t))}function E(t,e){return Object.keys(t).reduce(function(t,n){return o(e)===o(n)?n:t},null)}function O(t){var n=this||{},o=x(n.$vm);return function(t){k.call(arguments,1).forEach(function(e){for(var n in e)void 0===t[n]&&(t[n]=e[n])})}(t||{},n.$options,O.options),O.interceptors.forEach(function(t){r(t)&&(t=O.interceptor[t]),i(t)&&o.use(t)}),o(new D(t)).then(function(t){return t.ok?t:e.reject(t)},function(t){return t instanceof Error&&function(t){"undefined"!=typeof console&&console.error(t)}(t),e.reject(t)})}function P(t,e,n,o){var r=this||{},i={};return n=L({},P.actions,n),f(n,function(n,s){n=p({url:t,params:L({},e)},o,n),i[s]=function(){return(r.$http||O)(function(t,e){var n,o=L({},t),r={};switch(e.length){case 2:r=e[0],n=e[1];break;case 1:/^(POST|PUT|PATCH)$/i.test(o.method)?n=e[0]:r=e[0];break;case 0:break;default:throw"Expected up to 2 arguments [params, body], got "+e.length+" arguments"}return o.body=n,o.params=L({},o.params,r),o}(n,arguments))}}),i}function C(t){C.installed||(!function(t){var e=t.config,n=t.nextTick;A=n,I=e.debug||!e.silent}(t),t.url=b,t.http=O,t.resource=P,t.Promise=e,Object.defineProperties(t.prototype,{$url:{get:function(){return c(t.url,this,this.$options.url)}},$http:{get:function(){return c(t.http,this,this.$options.http)}},$resource:{get:function(){return t.resource.bind(this)}},$promise:{get:function(){var e=this;return function(n){return new t.Promise(n,e)}}}}))}var $=2;t.reject=function(e){return new t(function(t,n){n(e)})},t.resolve=function(e){return new t(function(t,n){t(e)})},t.all=function(e){return new t(function(n,o){function r(t){return function(o){s[t]=o,(i+=1)===e.length&&n(s)}}var i=0,s=[];0===e.length&&n(s);for(var u=0;u<e.length;u+=1)t.resolve(e[u]).then(r(u),o)})},t.race=function(e){return new t(function(n,o){for(var r=0;r<e.length;r+=1)t.resolve(e[r]).then(n,o)})};var U=t.prototype;U.resolve=function(t){var e=this;if(e.state===$){if(t===e)throw new TypeError("Promise settled with itself.");var n=!1;try{var o=t&&t.then;if(null!==t&&"object"==typeof t&&"function"==typeof o)return void o.call(t,function(t){n||e.resolve(t),n=!0},function(t){n||e.reject(t),n=!0})}catch(t){return void(n||e.reject(t))}e.state=0,e.value=t,e.notify()}},U.reject=function(t){if(this.state===$){if(t===this)throw new TypeError("Promise settled with itself.");this.state=1,this.value=t,this.notify()}},U.notify=function(){var t=this;!function(t,e){A(t,e)}(function(){if(t.state!==$)for(;t.deferred.length;){var e=t.deferred.shift(),n=e[0],o=e[1],r=e[2],i=e[3];try{0===t.state?r("function"==typeof n?n.call(void 0,t.value):t.value):1===t.state&&("function"==typeof o?r(o.call(void 0,t.value)):i(t.value))}catch(t){i(t)}}})},U.then=function(e,n){var o=this;return new t(function(t,r){o.deferred.push([e,n,t,r]),o.notify()})},U.catch=function(t){return this.then(void 0,t)},"undefined"==typeof Promise&&(window.Promise=t),e.all=function(t,n){return new e(Promise.all(t),n)},e.resolve=function(t,n){return new e(Promise.resolve(t),n)},e.reject=function(t,n){return new e(Promise.reject(t),n)},e.race=function(t,n){return new e(Promise.race(t),n)};var R=e.prototype;R.bind=function(t){return this.context=t,this},R.then=function(t,n){return t&&t.bind&&this.context&&(t=t.bind(this.context)),n&&n.bind&&this.context&&(n=n.bind(this.context)),new e(this.promise.then(t,n),this.context)},R.catch=function(t){return t&&t.bind&&this.context&&(t=t.bind(this.context)),new e(this.promise.catch(t),this.context)},R.finally=function(t){return this.then(function(e){return t.call(this),e},function(e){return t.call(this),Promise.reject(e)})};var A,S={}.hasOwnProperty,k=[].slice,I=!1,q="undefined"!=typeof window,H=Array.isArray,L=Object.assign||function(t){return k.call(arguments,1).forEach(function(e){h(t,e)}),t};b.options={url:"",root:null,params:{}},b.transform={template:function(t){var e=[],n=d(t.url,t.params,e);return e.forEach(function(e){delete t.params[e]}),n},query:function(t,e){var n=Object.keys(b.options.params),o={},r=e(t);return f(t.params,function(t,e){-1===n.indexOf(e)&&(o[e]=t)}),(o=b.params(o))&&(r+=(-1==r.indexOf("?")?"?":"&")+o),r},root:function(t,e){var n=e(t);return r(t.root)&&!/^(https?:)?\//.test(n)&&(n=function(t,e){return t&&void 0===e?t.replace(/\s+$/,""):t&&e?t.replace(new RegExp("["+e+"]+$"),""):t}(t.root,"/")+"/"+n),n}},b.transforms=["template","query","root"],b.params=function(t){var e=[],n=encodeURIComponent;return e.add=function(t,e){i(e)&&(e=e()),null===e&&(e=""),this.push(n(t)+"="+n(e))},g(e,t),e.join("&").replace(/%20/g,"+")},b.parse=function(t){var e=document.createElement("a");return document.documentMode&&(e.href=t,t=e.href),e.href=t,{href:e.href,protocol:e.protocol?e.protocol.replace(/:$/,""):"",port:e.port,host:e.host,hostname:e.hostname,pathname:"/"===e.pathname.charAt(0)?e.pathname:"/"+e.pathname,search:e.search?e.search.replace(/^\?/,""):"",hash:e.hash?e.hash.replace(/^#/,""):""}};var B=q&&"withCredentials"in new XMLHttpRequest,M=function(t){var e=this;this.map={},f(t,function(t,n){return e.append(n,t)})};M.prototype.has=function(t){return null!==E(this.map,t)},M.prototype.get=function(t){var e=this.map[E(this.map,t)];return e?e.join():null},M.prototype.getAll=function(t){return this.map[E(this.map,t)]||[]},M.prototype.set=function(t,e){this.map[function(t){if(/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(t))throw new TypeError("Invalid character in header field name");return n(t)}(E(this.map,t)||t)]=[n(e)]},M.prototype.append=function(t,e){var o=this.map[E(this.map,t)];o?o.push(n(e)):this.set(t,e)},M.prototype.delete=function(t){delete this.map[E(this.map,t)]},M.prototype.deleteAll=function(){this.map={}},M.prototype.forEach=function(t,e){var n=this;f(this.map,function(o,r){f(o,function(o){return t.call(e,o,r,n)})})};var N=function(t,n){var o=n.url,i=n.headers,s=n.status,u=n.statusText;this.url=o,this.ok=s>=200&&s<300,this.status=s||0,this.statusText=u||"",this.headers=new M(i),this.body=t,r(t)?this.bodyText=t:function(t){return"undefined"!=typeof Blob&&t instanceof Blob}(t)&&(this.bodyBlob=t,function(t){return 0===t.type.indexOf("text")||-1!==t.type.indexOf("json")}(t)&&(this.bodyText=function(t){return new e(function(e){var n=new FileReader;n.readAsText(t),n.onload=function(){e(n.result)}})}(t)))};N.prototype.blob=function(){return a(this.bodyBlob)},N.prototype.text=function(){return a(this.bodyText)},N.prototype.json=function(){return a(this.text(),function(t){return JSON.parse(t)})},Object.defineProperty(N.prototype,"data",{get:function(){return this.body},set:function(t){this.body=t}});var D=function(t){this.body=null,this.params={},L(this,t,{method:function(t){return t?t.toUpperCase():""}(t.method||"GET")}),this.headers instanceof M||(this.headers=new M(this.headers))};D.prototype.getUrl=function(){return b(this)},D.prototype.getBody=function(){return this.body},D.prototype.respondWith=function(t,e){return new N(t,L(e||{},{url:this.getUrl()}))};var J={"Content-Type":"application/json;charset=utf-8"};return O.options={},O.headers={put:J,post:J,patch:J,delete:J,common:{Accept:"application/json, text/plain, */*"},custom:{}},O.interceptor={before:function(t,e){i(t.before)&&t.before.call(this,t),e()},method:function(t,e){t.emulateHTTP&&/^(PUT|PATCH|DELETE)$/i.test(t.method)&&(t.headers.set("X-HTTP-Method-Override",t.method),t.method="POST"),e()},jsonp:function(t,e){"JSONP"==t.method&&(t.client=T),e()},json:function(t,e){var n=t.headers.get("Content-Type")||"";s(t.body)&&0===n.indexOf("application/json")&&(t.body=JSON.stringify(t.body)),e(function(t){return t.bodyText?a(t.text(),function(e){if(0===(n=t.headers.get("Content-Type")||"").indexOf("application/json")||function(t){var e=t.match(/^\s*(\[|\{)/);return e&&{"[":/]\s*$/,"{":/}\s*$/}[e[1]].test(t)}(e))try{t.body=JSON.parse(e)}catch(e){t.body=null}else t.body=e;return t}):t})},form:function(t,e){!function(t){return"undefined"!=typeof FormData&&t instanceof FormData}(t.body)?s(t.body)&&t.emulateJSON&&(t.body=b.params(t.body),t.headers.set("Content-Type","application/x-www-form-urlencoded")):t.headers.delete("Content-Type"),e()},header:function(t,e){f(L({},O.headers.common,t.crossOrigin?{}:O.headers.custom,O.headers[o(t.method)]),function(e,n){t.headers.has(n)||t.headers.set(n,e)}),e()},cors:function(t,e){if(q){var n=b.parse(location.href),o=b.parse(t.getUrl());o.protocol===n.protocol&&o.host===n.host||(t.crossOrigin=!0,t.emulateHTTP=!1,B||(t.client=w))}e()}},O.interceptors=["before","method","jsonp","json","form","header","cors"],["get","delete","head","jsonp"].forEach(function(t){O[t]=function(e,n){return this(L(n||{},{url:e,method:t}))}}),["post","put","patch"].forEach(function(t){O[t]=function(e,n,o){return this(L(o||{},{url:e,method:t,body:n}))}}),P.actions={get:{method:"GET"},save:{method:"POST"},query:{method:"GET"},update:{method:"PUT"},remove:{method:"DELETE"},delete:{method:"DELETE"}},"undefined"!=typeof window&&window.Vue&&window.Vue.use(C),C});


--------------------------------------------------------------------------------
/vendor/assets/javascripts/dist/vue-router.js:
--------------------------------------------------------------------------------
   1 | /**
   2 |   * vue-router v3.0.1
   3 |   * (c) 2017 Evan You
   4 |   * @license MIT
   5 |   */
   6 | (function (global, factory) {
   7 | 	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   8 | 	typeof define === 'function' && define.amd ? define(factory) :
   9 | 	(global.VueRouter = factory());
  10 | }(this, (function () { 'use strict';
  11 | 
  12 | /*  */
  13 | 
  14 | function assert (condition, message) {
  15 |   if (!condition) {
  16 |     throw new Error(("[vue-router] " + message))
  17 |   }
  18 | }
  19 | 
  20 | function warn (condition, message) {
  21 |   if ("development" !== 'production' && !condition) {
  22 |     typeof console !== 'undefined' && console.warn(("[vue-router] " + message));
  23 |   }
  24 | }
  25 | 
  26 | function isError (err) {
  27 |   return Object.prototype.toString.call(err).indexOf('Error') > -1
  28 | }
  29 | 
  30 | var View = {
  31 |   name: 'router-view',
  32 |   functional: true,
  33 |   props: {
  34 |     name: {
  35 |       type: String,
  36 |       default: 'default'
  37 |     }
  38 |   },
  39 |   render: function render (_, ref) {
  40 |     var props = ref.props;
  41 |     var children = ref.children;
  42 |     var parent = ref.parent;
  43 |     var data = ref.data;
  44 | 
  45 |     data.routerView = true;
  46 | 
  47 |     // directly use parent context's createElement() function
  48 |     // so that components rendered by router-view can resolve named slots
  49 |     var h = parent.$createElement;
  50 |     var name = props.name;
  51 |     var route = parent.$route;
  52 |     var cache = parent._routerViewCache || (parent._routerViewCache = {});
  53 | 
  54 |     // determine current view depth, also check to see if the tree
  55 |     // has been toggled inactive but kept-alive.
  56 |     var depth = 0;
  57 |     var inactive = false;
  58 |     while (parent && parent._routerRoot !== parent) {
  59 |       if (parent.$vnode && parent.$vnode.data.routerView) {
  60 |         depth++;
  61 |       }
  62 |       if (parent._inactive) {
  63 |         inactive = true;
  64 |       }
  65 |       parent = parent.$parent;
  66 |     }
  67 |     data.routerViewDepth = depth;
  68 | 
  69 |     // render previous view if the tree is inactive and kept-alive
  70 |     if (inactive) {
  71 |       return h(cache[name], data, children)
  72 |     }
  73 | 
  74 |     var matched = route.matched[depth];
  75 |     // render empty node if no matched route
  76 |     if (!matched) {
  77 |       cache[name] = null;
  78 |       return h()
  79 |     }
  80 | 
  81 |     var component = cache[name] = matched.components[name];
  82 | 
  83 |     // attach instance registration hook
  84 |     // this will be called in the instance's injected lifecycle hooks
  85 |     data.registerRouteInstance = function (vm, val) {
  86 |       // val could be undefined for unregistration
  87 |       var current = matched.instances[name];
  88 |       if (
  89 |         (val && current !== vm) ||
  90 |         (!val && current === vm)
  91 |       ) {
  92 |         matched.instances[name] = val;
  93 |       }
  94 |     }
  95 | 
  96 |     // also register instance in prepatch hook
  97 |     // in case the same component instance is reused across different routes
  98 |     ;(data.hook || (data.hook = {})).prepatch = function (_, vnode) {
  99 |       matched.instances[name] = vnode.componentInstance;
 100 |     };
 101 | 
 102 |     // resolve props
 103 |     var propsToPass = data.props = resolveProps(route, matched.props && matched.props[name]);
 104 |     if (propsToPass) {
 105 |       // clone to prevent mutation
 106 |       propsToPass = data.props = extend({}, propsToPass);
 107 |       // pass non-declared props as attrs
 108 |       var attrs = data.attrs = data.attrs || {};
 109 |       for (var key in propsToPass) {
 110 |         if (!component.props || !(key in component.props)) {
 111 |           attrs[key] = propsToPass[key];
 112 |           delete propsToPass[key];
 113 |         }
 114 |       }
 115 |     }
 116 | 
 117 |     return h(component, data, children)
 118 |   }
 119 | };
 120 | 
 121 | function resolveProps (route, config) {
 122 |   switch (typeof config) {
 123 |     case 'undefined':
 124 |       return
 125 |     case 'object':
 126 |       return config
 127 |     case 'function':
 128 |       return config(route)
 129 |     case 'boolean':
 130 |       return config ? route.params : undefined
 131 |     default:
 132 |       {
 133 |         warn(
 134 |           false,
 135 |           "props in \"" + (route.path) + "\" is a " + (typeof config) + ", " +
 136 |           "expecting an object, function or boolean."
 137 |         );
 138 |       }
 139 |   }
 140 | }
 141 | 
 142 | function extend (to, from) {
 143 |   for (var key in from) {
 144 |     to[key] = from[key];
 145 |   }
 146 |   return to
 147 | }
 148 | 
 149 | /*  */
 150 | 
 151 | var encodeReserveRE = /[!'()*]/g;
 152 | var encodeReserveReplacer = function (c) { return '%' + c.charCodeAt(0).toString(16); };
 153 | var commaRE = /%2C/g;
 154 | 
 155 | // fixed encodeURIComponent which is more conformant to RFC3986:
 156 | // - escapes [!'()*]
 157 | // - preserve commas
 158 | var encode = function (str) { return encodeURIComponent(str)
 159 |   .replace(encodeReserveRE, encodeReserveReplacer)
 160 |   .replace(commaRE, ','); };
 161 | 
 162 | var decode = decodeURIComponent;
 163 | 
 164 | function resolveQuery (
 165 |   query,
 166 |   extraQuery,
 167 |   _parseQuery
 168 | ) {
 169 |   if ( extraQuery === void 0 ) extraQuery = {};
 170 | 
 171 |   var parse = _parseQuery || parseQuery;
 172 |   var parsedQuery;
 173 |   try {
 174 |     parsedQuery = parse(query || '');
 175 |   } catch (e) {
 176 |     "development" !== 'production' && warn(false, e.message);
 177 |     parsedQuery = {};
 178 |   }
 179 |   for (var key in extraQuery) {
 180 |     parsedQuery[key] = extraQuery[key];
 181 |   }
 182 |   return parsedQuery
 183 | }
 184 | 
 185 | function parseQuery (query) {
 186 |   var res = {};
 187 | 
 188 |   query = query.trim().replace(/^(\?|#|&)/, '');
 189 | 
 190 |   if (!query) {
 191 |     return res
 192 |   }
 193 | 
 194 |   query.split('&').forEach(function (param) {
 195 |     var parts = param.replace(/\+/g, ' ').split('=');
 196 |     var key = decode(parts.shift());
 197 |     var val = parts.length > 0
 198 |       ? decode(parts.join('='))
 199 |       : null;
 200 | 
 201 |     if (res[key] === undefined) {
 202 |       res[key] = val;
 203 |     } else if (Array.isArray(res[key])) {
 204 |       res[key].push(val);
 205 |     } else {
 206 |       res[key] = [res[key], val];
 207 |     }
 208 |   });
 209 | 
 210 |   return res
 211 | }
 212 | 
 213 | function stringifyQuery (obj) {
 214 |   var res = obj ? Object.keys(obj).map(function (key) {
 215 |     var val = obj[key];
 216 | 
 217 |     if (val === undefined) {
 218 |       return ''
 219 |     }
 220 | 
 221 |     if (val === null) {
 222 |       return encode(key)
 223 |     }
 224 | 
 225 |     if (Array.isArray(val)) {
 226 |       var result = [];
 227 |       val.forEach(function (val2) {
 228 |         if (val2 === undefined) {
 229 |           return
 230 |         }
 231 |         if (val2 === null) {
 232 |           result.push(encode(key));
 233 |         } else {
 234 |           result.push(encode(key) + '=' + encode(val2));
 235 |         }
 236 |       });
 237 |       return result.join('&')
 238 |     }
 239 | 
 240 |     return encode(key) + '=' + encode(val)
 241 |   }).filter(function (x) { return x.length > 0; }).join('&') : null;
 242 |   return res ? ("?" + res) : ''
 243 | }
 244 | 
 245 | /*  */
 246 | 
 247 | 
 248 | var trailingSlashRE = /\/?$/;
 249 | 
 250 | function createRoute (
 251 |   record,
 252 |   location,
 253 |   redirectedFrom,
 254 |   router
 255 | ) {
 256 |   var stringifyQuery$$1 = router && router.options.stringifyQuery;
 257 | 
 258 |   var query = location.query || {};
 259 |   try {
 260 |     query = clone(query);
 261 |   } catch (e) {}
 262 | 
 263 |   var route = {
 264 |     name: location.name || (record && record.name),
 265 |     meta: (record && record.meta) || {},
 266 |     path: location.path || '/',
 267 |     hash: location.hash || '',
 268 |     query: query,
 269 |     params: location.params || {},
 270 |     fullPath: getFullPath(location, stringifyQuery$$1),
 271 |     matched: record ? formatMatch(record) : []
 272 |   };
 273 |   if (redirectedFrom) {
 274 |     route.redirectedFrom = getFullPath(redirectedFrom, stringifyQuery$$1);
 275 |   }
 276 |   return Object.freeze(route)
 277 | }
 278 | 
 279 | function clone (value) {
 280 |   if (Array.isArray(value)) {
 281 |     return value.map(clone)
 282 |   } else if (value && typeof value === 'object') {
 283 |     var res = {};
 284 |     for (var key in value) {
 285 |       res[key] = clone(value[key]);
 286 |     }
 287 |     return res
 288 |   } else {
 289 |     return value
 290 |   }
 291 | }
 292 | 
 293 | // the starting route that represents the initial state
 294 | var START = createRoute(null, {
 295 |   path: '/'
 296 | });
 297 | 
 298 | function formatMatch (record) {
 299 |   var res = [];
 300 |   while (record) {
 301 |     res.unshift(record);
 302 |     record = record.parent;
 303 |   }
 304 |   return res
 305 | }
 306 | 
 307 | function getFullPath (
 308 |   ref,
 309 |   _stringifyQuery
 310 | ) {
 311 |   var path = ref.path;
 312 |   var query = ref.query; if ( query === void 0 ) query = {};
 313 |   var hash = ref.hash; if ( hash === void 0 ) hash = '';
 314 | 
 315 |   var stringify = _stringifyQuery || stringifyQuery;
 316 |   return (path || '/') + stringify(query) + hash
 317 | }
 318 | 
 319 | function isSameRoute (a, b) {
 320 |   if (b === START) {
 321 |     return a === b
 322 |   } else if (!b) {
 323 |     return false
 324 |   } else if (a.path && b.path) {
 325 |     return (
 326 |       a.path.replace(trailingSlashRE, '') === b.path.replace(trailingSlashRE, '') &&
 327 |       a.hash === b.hash &&
 328 |       isObjectEqual(a.query, b.query)
 329 |     )
 330 |   } else if (a.name && b.name) {
 331 |     return (
 332 |       a.name === b.name &&
 333 |       a.hash === b.hash &&
 334 |       isObjectEqual(a.query, b.query) &&
 335 |       isObjectEqual(a.params, b.params)
 336 |     )
 337 |   } else {
 338 |     return false
 339 |   }
 340 | }
 341 | 
 342 | function isObjectEqual (a, b) {
 343 |   if ( a === void 0 ) a = {};
 344 |   if ( b === void 0 ) b = {};
 345 | 
 346 |   // handle null value #1566
 347 |   if (!a || !b) { return a === b }
 348 |   var aKeys = Object.keys(a);
 349 |   var bKeys = Object.keys(b);
 350 |   if (aKeys.length !== bKeys.length) {
 351 |     return false
 352 |   }
 353 |   return aKeys.every(function (key) {
 354 |     var aVal = a[key];
 355 |     var bVal = b[key];
 356 |     // check nested equality
 357 |     if (typeof aVal === 'object' && typeof bVal === 'object') {
 358 |       return isObjectEqual(aVal, bVal)
 359 |     }
 360 |     return String(aVal) === String(bVal)
 361 |   })
 362 | }
 363 | 
 364 | function isIncludedRoute (current, target) {
 365 |   return (
 366 |     current.path.replace(trailingSlashRE, '/').indexOf(
 367 |       target.path.replace(trailingSlashRE, '/')
 368 |     ) === 0 &&
 369 |     (!target.hash || current.hash === target.hash) &&
 370 |     queryIncludes(current.query, target.query)
 371 |   )
 372 | }
 373 | 
 374 | function queryIncludes (current, target) {
 375 |   for (var key in target) {
 376 |     if (!(key in current)) {
 377 |       return false
 378 |     }
 379 |   }
 380 |   return true
 381 | }
 382 | 
 383 | /*  */
 384 | 
 385 | // work around weird flow bug
 386 | var toTypes = [String, Object];
 387 | var eventTypes = [String, Array];
 388 | 
 389 | var Link = {
 390 |   name: 'router-link',
 391 |   props: {
 392 |     to: {
 393 |       type: toTypes,
 394 |       required: true
 395 |     },
 396 |     tag: {
 397 |       type: String,
 398 |       default: 'a'
 399 |     },
 400 |     exact: Boolean,
 401 |     append: Boolean,
 402 |     replace: Boolean,
 403 |     activeClass: String,
 404 |     exactActiveClass: String,
 405 |     event: {
 406 |       type: eventTypes,
 407 |       default: 'click'
 408 |     }
 409 |   },
 410 |   render: function render (h) {
 411 |     var this$1 = this;
 412 | 
 413 |     var router = this.$router;
 414 |     var current = this.$route;
 415 |     var ref = router.resolve(this.to, current, this.append);
 416 |     var location = ref.location;
 417 |     var route = ref.route;
 418 |     var href = ref.href;
 419 | 
 420 |     var classes = {};
 421 |     var globalActiveClass = router.options.linkActiveClass;
 422 |     var globalExactActiveClass = router.options.linkExactActiveClass;
 423 |     // Support global empty active class
 424 |     var activeClassFallback = globalActiveClass == null
 425 |             ? 'router-link-active'
 426 |             : globalActiveClass;
 427 |     var exactActiveClassFallback = globalExactActiveClass == null
 428 |             ? 'router-link-exact-active'
 429 |             : globalExactActiveClass;
 430 |     var activeClass = this.activeClass == null
 431 |             ? activeClassFallback
 432 |             : this.activeClass;
 433 |     var exactActiveClass = this.exactActiveClass == null
 434 |             ? exactActiveClassFallback
 435 |             : this.exactActiveClass;
 436 |     var compareTarget = location.path
 437 |       ? createRoute(null, location, null, router)
 438 |       : route;
 439 | 
 440 |     classes[exactActiveClass] = isSameRoute(current, compareTarget);
 441 |     classes[activeClass] = this.exact
 442 |       ? classes[exactActiveClass]
 443 |       : isIncludedRoute(current, compareTarget);
 444 | 
 445 |     var handler = function (e) {
 446 |       if (guardEvent(e)) {
 447 |         if (this$1.replace) {
 448 |           router.replace(location);
 449 |         } else {
 450 |           router.push(location);
 451 |         }
 452 |       }
 453 |     };
 454 | 
 455 |     var on = { click: guardEvent };
 456 |     if (Array.isArray(this.event)) {
 457 |       this.event.forEach(function (e) { on[e] = handler; });
 458 |     } else {
 459 |       on[this.event] = handler;
 460 |     }
 461 | 
 462 |     var data = {
 463 |       class: classes
 464 |     };
 465 | 
 466 |     if (this.tag === 'a') {
 467 |       data.on = on;
 468 |       data.attrs = { href: href };
 469 |     } else {
 470 |       // find the first <a> child and apply listener and href
 471 |       var a = findAnchor(this.$slots.default);
 472 |       if (a) {
 473 |         // in case the <a> is a static node
 474 |         a.isStatic = false;
 475 |         var extend = _Vue.util.extend;
 476 |         var aData = a.data = extend({}, a.data);
 477 |         aData.on = on;
 478 |         var aAttrs = a.data.attrs = extend({}, a.data.attrs);
 479 |         aAttrs.href = href;
 480 |       } else {
 481 |         // doesn't have <a> child, apply listener to self
 482 |         data.on = on;
 483 |       }
 484 |     }
 485 | 
 486 |     return h(this.tag, data, this.$slots.default)
 487 |   }
 488 | };
 489 | 
 490 | function guardEvent (e) {
 491 |   // don't redirect with control keys
 492 |   if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) { return }
 493 |   // don't redirect when preventDefault called
 494 |   if (e.defaultPrevented) { return }
 495 |   // don't redirect on right click
 496 |   if (e.button !== undefined && e.button !== 0) { return }
 497 |   // don't redirect if `target="_blank"`
 498 |   if (e.currentTarget && e.currentTarget.getAttribute) {
 499 |     var target = e.currentTarget.getAttribute('target');
 500 |     if (/\b_blank\b/i.test(target)) { return }
 501 |   }
 502 |   // this may be a Weex event which doesn't have this method
 503 |   if (e.preventDefault) {
 504 |     e.preventDefault();
 505 |   }
 506 |   return true
 507 | }
 508 | 
 509 | function findAnchor (children) {
 510 |   if (children) {
 511 |     var child;
 512 |     for (var i = 0; i < children.length; i++) {
 513 |       child = children[i];
 514 |       if (child.tag === 'a') {
 515 |         return child
 516 |       }
 517 |       if (child.children && (child = findAnchor(child.children))) {
 518 |         return child
 519 |       }
 520 |     }
 521 |   }
 522 | }
 523 | 
 524 | var _Vue;
 525 | 
 526 | function install (Vue) {
 527 |   if (install.installed && _Vue === Vue) { return }
 528 |   install.installed = true;
 529 | 
 530 |   _Vue = Vue;
 531 | 
 532 |   var isDef = function (v) { return v !== undefined; };
 533 | 
 534 |   var registerInstance = function (vm, callVal) {
 535 |     var i = vm.$options._parentVnode;
 536 |     if (isDef(i) && isDef(i = i.data) && isDef(i = i.registerRouteInstance)) {
 537 |       i(vm, callVal);
 538 |     }
 539 |   };
 540 | 
 541 |   Vue.mixin({
 542 |     beforeCreate: function beforeCreate () {
 543 |       if (isDef(this.$options.router)) {
 544 |         this._routerRoot = this;
 545 |         this._router = this.$options.router;
 546 |         this._router.init(this);
 547 |         Vue.util.defineReactive(this, '_route', this._router.history.current);
 548 |       } else {
 549 |         this._routerRoot = (this.$parent && this.$parent._routerRoot) || this;
 550 |       }
 551 |       registerInstance(this, this);
 552 |     },
 553 |     destroyed: function destroyed () {
 554 |       registerInstance(this);
 555 |     }
 556 |   });
 557 | 
 558 |   Object.defineProperty(Vue.prototype, '$router', {
 559 |     get: function get () { return this._routerRoot._router }
 560 |   });
 561 | 
 562 |   Object.defineProperty(Vue.prototype, '$route', {
 563 |     get: function get () { return this._routerRoot._route }
 564 |   });
 565 | 
 566 |   Vue.component('router-view', View);
 567 |   Vue.component('router-link', Link);
 568 | 
 569 |   var strats = Vue.config.optionMergeStrategies;
 570 |   // use the same hook merging strategy for route hooks
 571 |   strats.beforeRouteEnter = strats.beforeRouteLeave = strats.beforeRouteUpdate = strats.created;
 572 | }
 573 | 
 574 | /*  */
 575 | 
 576 | var inBrowser = typeof window !== 'undefined';
 577 | 
 578 | /*  */
 579 | 
 580 | function resolvePath (
 581 |   relative,
 582 |   base,
 583 |   append
 584 | ) {
 585 |   var firstChar = relative.charAt(0);
 586 |   if (firstChar === '/') {
 587 |     return relative
 588 |   }
 589 | 
 590 |   if (firstChar === '?' || firstChar === '#') {
 591 |     return base + relative
 592 |   }
 593 | 
 594 |   var stack = base.split('/');
 595 | 
 596 |   // remove trailing segment if:
 597 |   // - not appending
 598 |   // - appending to trailing slash (last segment is empty)
 599 |   if (!append || !stack[stack.length - 1]) {
 600 |     stack.pop();
 601 |   }
 602 | 
 603 |   // resolve relative path
 604 |   var segments = relative.replace(/^\//, '').split('/');
 605 |   for (var i = 0; i < segments.length; i++) {
 606 |     var segment = segments[i];
 607 |     if (segment === '..') {
 608 |       stack.pop();
 609 |     } else if (segment !== '.') {
 610 |       stack.push(segment);
 611 |     }
 612 |   }
 613 | 
 614 |   // ensure leading slash
 615 |   if (stack[0] !== '') {
 616 |     stack.unshift('');
 617 |   }
 618 | 
 619 |   return stack.join('/')
 620 | }
 621 | 
 622 | function parsePath (path) {
 623 |   var hash = '';
 624 |   var query = '';
 625 | 
 626 |   var hashIndex = path.indexOf('#');
 627 |   if (hashIndex >= 0) {
 628 |     hash = path.slice(hashIndex);
 629 |     path = path.slice(0, hashIndex);
 630 |   }
 631 | 
 632 |   var queryIndex = path.indexOf('?');
 633 |   if (queryIndex >= 0) {
 634 |     query = path.slice(queryIndex + 1);
 635 |     path = path.slice(0, queryIndex);
 636 |   }
 637 | 
 638 |   return {
 639 |     path: path,
 640 |     query: query,
 641 |     hash: hash
 642 |   }
 643 | }
 644 | 
 645 | function cleanPath (path) {
 646 |   return path.replace(/\/\//g, '/')
 647 | }
 648 | 
 649 | var isarray = Array.isArray || function (arr) {
 650 |   return Object.prototype.toString.call(arr) == '[object Array]';
 651 | };
 652 | 
 653 | /**
 654 |  * Expose `pathToRegexp`.
 655 |  */
 656 | var pathToRegexp_1 = pathToRegexp;
 657 | var parse_1 = parse;
 658 | var compile_1 = compile;
 659 | var tokensToFunction_1 = tokensToFunction;
 660 | var tokensToRegExp_1 = tokensToRegExp;
 661 | 
 662 | /**
 663 |  * The main path matching regexp utility.
 664 |  *
 665 |  * @type {RegExp}
 666 |  */
 667 | var PATH_REGEXP = new RegExp([
 668 |   // Match escaped characters that would otherwise appear in future matches.
 669 |   // This allows the user to escape special characters that won't transform.
 670 |   '(\\\\.)',
 671 |   // Match Express-style parameters and un-named parameters with a prefix
 672 |   // and optional suffixes. Matches appear as:
 673 |   //
 674 |   // "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined]
 675 |   // "/route(\\d+)"  => [undefined, undefined, undefined, "\d+", undefined, undefined]
 676 |   // "/*"            => ["/", undefined, undefined, undefined, undefined, "*"]
 677 |   '([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))'
 678 | ].join('|'), 'g');
 679 | 
 680 | /**
 681 |  * Parse a string for the raw tokens.
 682 |  *
 683 |  * @param  {string}  str
 684 |  * @param  {Object=} options
 685 |  * @return {!Array}
 686 |  */
 687 | function parse (str, options) {
 688 |   var tokens = [];
 689 |   var key = 0;
 690 |   var index = 0;
 691 |   var path = '';
 692 |   var defaultDelimiter = options && options.delimiter || '/';
 693 |   var res;
 694 | 
 695 |   while ((res = PATH_REGEXP.exec(str)) != null) {
 696 |     var m = res[0];
 697 |     var escaped = res[1];
 698 |     var offset = res.index;
 699 |     path += str.slice(index, offset);
 700 |     index = offset + m.length;
 701 | 
 702 |     // Ignore already escaped sequences.
 703 |     if (escaped) {
 704 |       path += escaped[1];
 705 |       continue
 706 |     }
 707 | 
 708 |     var next = str[index];
 709 |     var prefix = res[2];
 710 |     var name = res[3];
 711 |     var capture = res[4];
 712 |     var group = res[5];
 713 |     var modifier = res[6];
 714 |     var asterisk = res[7];
 715 | 
 716 |     // Push the current path onto the tokens.
 717 |     if (path) {
 718 |       tokens.push(path);
 719 |       path = '';
 720 |     }
 721 | 
 722 |     var partial = prefix != null && next != null && next !== prefix;
 723 |     var repeat = modifier === '+' || modifier === '*';
 724 |     var optional = modifier === '?' || modifier === '*';
 725 |     var delimiter = res[2] || defaultDelimiter;
 726 |     var pattern = capture || group;
 727 | 
 728 |     tokens.push({
 729 |       name: name || key++,
 730 |       prefix: prefix || '',
 731 |       delimiter: delimiter,
 732 |       optional: optional,
 733 |       repeat: repeat,
 734 |       partial: partial,
 735 |       asterisk: !!asterisk,
 736 |       pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')
 737 |     });
 738 |   }
 739 | 
 740 |   // Match any characters still remaining.
 741 |   if (index < str.length) {
 742 |     path += str.substr(index);
 743 |   }
 744 | 
 745 |   // If the path exists, push it onto the end.
 746 |   if (path) {
 747 |     tokens.push(path);
 748 |   }
 749 | 
 750 |   return tokens
 751 | }
 752 | 
 753 | /**
 754 |  * Compile a string to a template function for the path.
 755 |  *
 756 |  * @param  {string}             str
 757 |  * @param  {Object=}            options
 758 |  * @return {!function(Object=, Object=)}
 759 |  */
 760 | function compile (str, options) {
 761 |   return tokensToFunction(parse(str, options))
 762 | }
 763 | 
 764 | /**
 765 |  * Prettier encoding of URI path segments.
 766 |  *
 767 |  * @param  {string}
 768 |  * @return {string}
 769 |  */
 770 | function encodeURIComponentPretty (str) {
 771 |   return encodeURI(str).replace(/[\/?#]/g, function (c) {
 772 |     return '%' + c.charCodeAt(0).toString(16).toUpperCase()
 773 |   })
 774 | }
 775 | 
 776 | /**
 777 |  * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.
 778 |  *
 779 |  * @param  {string}
 780 |  * @return {string}
 781 |  */
 782 | function encodeAsterisk (str) {
 783 |   return encodeURI(str).replace(/[?#]/g, function (c) {
 784 |     return '%' + c.charCodeAt(0).toString(16).toUpperCase()
 785 |   })
 786 | }
 787 | 
 788 | /**
 789 |  * Expose a method for transforming tokens into the path function.
 790 |  */
 791 | function tokensToFunction (tokens) {
 792 |   // Compile all the tokens into regexps.
 793 |   var matches = new Array(tokens.length);
 794 | 
 795 |   // Compile all the patterns before compilation.
 796 |   for (var i = 0; i < tokens.length; i++) {
 797 |     if (typeof tokens[i] === 'object') {
 798 |       matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$');
 799 |     }
 800 |   }
 801 | 
 802 |   return function (obj, opts) {
 803 |     var path = '';
 804 |     var data = obj || {};
 805 |     var options = opts || {};
 806 |     var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent;
 807 | 
 808 |     for (var i = 0; i < tokens.length; i++) {
 809 |       var token = tokens[i];
 810 | 
 811 |       if (typeof token === 'string') {
 812 |         path += token;
 813 | 
 814 |         continue
 815 |       }
 816 | 
 817 |       var value = data[token.name];
 818 |       var segment;
 819 | 
 820 |       if (value == null) {
 821 |         if (token.optional) {
 822 |           // Prepend partial segment prefixes.
 823 |           if (token.partial) {
 824 |             path += token.prefix;
 825 |           }
 826 | 
 827 |           continue
 828 |         } else {
 829 |           throw new TypeError('Expected "' + token.name + '" to be defined')
 830 |         }
 831 |       }
 832 | 
 833 |       if (isarray(value)) {
 834 |         if (!token.repeat) {
 835 |           throw new TypeError('Expected "' + token.name + '" to not repeat, but received `' + JSON.stringify(value) + '`')
 836 |         }
 837 | 
 838 |         if (value.length === 0) {
 839 |           if (token.optional) {
 840 |             continue
 841 |           } else {
 842 |             throw new TypeError('Expected "' + token.name + '" to not be empty')
 843 |           }
 844 |         }
 845 | 
 846 |         for (var j = 0; j < value.length; j++) {
 847 |           segment = encode(value[j]);
 848 | 
 849 |           if (!matches[i].test(segment)) {
 850 |             throw new TypeError('Expected all "' + token.name + '" to match "' + token.pattern + '", but received `' + JSON.stringify(segment) + '`')
 851 |           }
 852 | 
 853 |           path += (j === 0 ? token.prefix : token.delimiter) + segment;
 854 |         }
 855 | 
 856 |         continue
 857 |       }
 858 | 
 859 |       segment = token.asterisk ? encodeAsterisk(value) : encode(value);
 860 | 
 861 |       if (!matches[i].test(segment)) {
 862 |         throw new TypeError('Expected "' + token.name + '" to match "' + token.pattern + '", but received "' + segment + '"')
 863 |       }
 864 | 
 865 |       path += token.prefix + segment;
 866 |     }
 867 | 
 868 |     return path
 869 |   }
 870 | }
 871 | 
 872 | /**
 873 |  * Escape a regular expression string.
 874 |  *
 875 |  * @param  {string} str
 876 |  * @return {string}
 877 |  */
 878 | function escapeString (str) {
 879 |   return str.replace(/([.+*?=^!:${}()[\]|\/\\])/g, '\\$1')
 880 | }
 881 | 
 882 | /**
 883 |  * Escape the capturing group by escaping special characters and meaning.
 884 |  *
 885 |  * @param  {string} group
 886 |  * @return {string}
 887 |  */
 888 | function escapeGroup (group) {
 889 |   return group.replace(/([=!:$\/()])/g, '\\$1')
 890 | }
 891 | 
 892 | /**
 893 |  * Attach the keys as a property of the regexp.
 894 |  *
 895 |  * @param  {!RegExp} re
 896 |  * @param  {Array}   keys
 897 |  * @return {!RegExp}
 898 |  */
 899 | function attachKeys (re, keys) {
 900 |   re.keys = keys;
 901 |   return re
 902 | }
 903 | 
 904 | /**
 905 |  * Get the flags for a regexp from the options.
 906 |  *
 907 |  * @param  {Object} options
 908 |  * @return {string}
 909 |  */
 910 | function flags (options) {
 911 |   return options.sensitive ? '' : 'i'
 912 | }
 913 | 
 914 | /**
 915 |  * Pull out keys from a regexp.
 916 |  *
 917 |  * @param  {!RegExp} path
 918 |  * @param  {!Array}  keys
 919 |  * @return {!RegExp}
 920 |  */
 921 | function regexpToRegexp (path, keys) {
 922 |   // Use a negative lookahead to match only capturing groups.
 923 |   var groups = path.source.match(/\((?!\?)/g);
 924 | 
 925 |   if (groups) {
 926 |     for (var i = 0; i < groups.length; i++) {
 927 |       keys.push({
 928 |         name: i,
 929 |         prefix: null,
 930 |         delimiter: null,
 931 |         optional: false,
 932 |         repeat: false,
 933 |         partial: false,
 934 |         asterisk: false,
 935 |         pattern: null
 936 |       });
 937 |     }
 938 |   }
 939 | 
 940 |   return attachKeys(path, keys)
 941 | }
 942 | 
 943 | /**
 944 |  * Transform an array into a regexp.
 945 |  *
 946 |  * @param  {!Array}  path
 947 |  * @param  {Array}   keys
 948 |  * @param  {!Object} options
 949 |  * @return {!RegExp}
 950 |  */
 951 | function arrayToRegexp (path, keys, options) {
 952 |   var parts = [];
 953 | 
 954 |   for (var i = 0; i < path.length; i++) {
 955 |     parts.push(pathToRegexp(path[i], keys, options).source);
 956 |   }
 957 | 
 958 |   var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));
 959 | 
 960 |   return attachKeys(regexp, keys)
 961 | }
 962 | 
 963 | /**
 964 |  * Create a path regexp from string input.
 965 |  *
 966 |  * @param  {string}  path
 967 |  * @param  {!Array}  keys
 968 |  * @param  {!Object} options
 969 |  * @return {!RegExp}
 970 |  */
 971 | function stringToRegexp (path, keys, options) {
 972 |   return tokensToRegExp(parse(path, options), keys, options)
 973 | }
 974 | 
 975 | /**
 976 |  * Expose a function for taking tokens and returning a RegExp.
 977 |  *
 978 |  * @param  {!Array}          tokens
 979 |  * @param  {(Array|Object)=} keys
 980 |  * @param  {Object=}         options
 981 |  * @return {!RegExp}
 982 |  */
 983 | function tokensToRegExp (tokens, keys, options) {
 984 |   if (!isarray(keys)) {
 985 |     options = /** @type {!Object} */ (keys || options);
 986 |     keys = [];
 987 |   }
 988 | 
 989 |   options = options || {};
 990 | 
 991 |   var strict = options.strict;
 992 |   var end = options.end !== false;
 993 |   var route = '';
 994 | 
 995 |   // Iterate over the tokens and create our regexp string.
 996 |   for (var i = 0; i < tokens.length; i++) {
 997 |     var token = tokens[i];
 998 | 
 999 |     if (typeof token === 'string') {
1000 |       route += escapeString(token);
1001 |     } else {
1002 |       var prefix = escapeString(token.prefix);
1003 |       var capture = '(?:' + token.pattern + ')';
1004 | 
1005 |       keys.push(token);
1006 | 
1007 |       if (token.repeat) {
1008 |         capture += '(?:' + prefix + capture + ')*';
1009 |       }
1010 | 
1011 |       if (token.optional) {
1012 |         if (!token.partial) {
1013 |           capture = '(?:' + prefix + '(' + capture + '))?';
1014 |         } else {
1015 |           capture = prefix + '(' + capture + ')?';
1016 |         }
1017 |       } else {
1018 |         capture = prefix + '(' + capture + ')';
1019 |       }
1020 | 
1021 |       route += capture;
1022 |     }
1023 |   }
1024 | 
1025 |   var delimiter = escapeString(options.delimiter || '/');
1026 |   var endsWithDelimiter = route.slice(-delimiter.length) === delimiter;
1027 | 
1028 |   // In non-strict mode we allow a slash at the end of match. If the path to
1029 |   // match already ends with a slash, we remove it for consistency. The slash
1030 |   // is valid at the end of a path match, not in the middle. This is important
1031 |   // in non-ending mode, where "/test/" shouldn't match "/test//route".
1032 |   if (!strict) {
1033 |     route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?';
1034 |   }
1035 | 
1036 |   if (end) {
1037 |     route += '$';
1038 |   } else {
1039 |     // In non-ending mode, we need the capturing groups to match as much as
1040 |     // possible by using a positive lookahead to the end or next path segment.
1041 |     route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';
1042 |   }
1043 | 
1044 |   return attachKeys(new RegExp('^' + route, flags(options)), keys)
1045 | }
1046 | 
1047 | /**
1048 |  * Normalize the given path string, returning a regular expression.
1049 |  *
1050 |  * An empty array can be passed in for the keys, which will hold the
1051 |  * placeholder key descriptions. For example, using `/user/:id`, `keys` will
1052 |  * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
1053 |  *
1054 |  * @param  {(string|RegExp|Array)} path
1055 |  * @param  {(Array|Object)=}       keys
1056 |  * @param  {Object=}               options
1057 |  * @return {!RegExp}
1058 |  */
1059 | function pathToRegexp (path, keys, options) {
1060 |   if (!isarray(keys)) {
1061 |     options = /** @type {!Object} */ (keys || options);
1062 |     keys = [];
1063 |   }
1064 | 
1065 |   options = options || {};
1066 | 
1067 |   if (path instanceof RegExp) {
1068 |     return regexpToRegexp(path, /** @type {!Array} */ (keys))
1069 |   }
1070 | 
1071 |   if (isarray(path)) {
1072 |     return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)
1073 |   }
1074 | 
1075 |   return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)
1076 | }
1077 | 
1078 | pathToRegexp_1.parse = parse_1;
1079 | pathToRegexp_1.compile = compile_1;
1080 | pathToRegexp_1.tokensToFunction = tokensToFunction_1;
1081 | pathToRegexp_1.tokensToRegExp = tokensToRegExp_1;
1082 | 
1083 | /*  */
1084 | 
1085 | // $flow-disable-line
1086 | var regexpCompileCache = Object.create(null);
1087 | 
1088 | function fillParams (
1089 |   path,
1090 |   params,
1091 |   routeMsg
1092 | ) {
1093 |   try {
1094 |     var filler =
1095 |       regexpCompileCache[path] ||
1096 |       (regexpCompileCache[path] = pathToRegexp_1.compile(path));
1097 |     return filler(params || {}, { pretty: true })
1098 |   } catch (e) {
1099 |     {
1100 |       warn(false, ("missing param for " + routeMsg + ": " + (e.message)));
1101 |     }
1102 |     return ''
1103 |   }
1104 | }
1105 | 
1106 | /*  */
1107 | 
1108 | function createRouteMap (
1109 |   routes,
1110 |   oldPathList,
1111 |   oldPathMap,
1112 |   oldNameMap
1113 | ) {
1114 |   // the path list is used to control path matching priority
1115 |   var pathList = oldPathList || [];
1116 |   // $flow-disable-line
1117 |   var pathMap = oldPathMap || Object.create(null);
1118 |   // $flow-disable-line
1119 |   var nameMap = oldNameMap || Object.create(null);
1120 | 
1121 |   routes.forEach(function (route) {
1122 |     addRouteRecord(pathList, pathMap, nameMap, route);
1123 |   });
1124 | 
1125 |   // ensure wildcard routes are always at the end
1126 |   for (var i = 0, l = pathList.length; i < l; i++) {
1127 |     if (pathList[i] === '*') {
1128 |       pathList.push(pathList.splice(i, 1)[0]);
1129 |       l--;
1130 |       i--;
1131 |     }
1132 |   }
1133 | 
1134 |   return {
1135 |     pathList: pathList,
1136 |     pathMap: pathMap,
1137 |     nameMap: nameMap
1138 |   }
1139 | }
1140 | 
1141 | function addRouteRecord (
1142 |   pathList,
1143 |   pathMap,
1144 |   nameMap,
1145 |   route,
1146 |   parent,
1147 |   matchAs
1148 | ) {
1149 |   var path = route.path;
1150 |   var name = route.name;
1151 |   {
1152 |     assert(path != null, "\"path\" is required in a route configuration.");
1153 |     assert(
1154 |       typeof route.component !== 'string',
1155 |       "route config \"component\" for path: " + (String(path || name)) + " cannot be a " +
1156 |       "string id. Use an actual component instead."
1157 |     );
1158 |   }
1159 | 
1160 |   var pathToRegexpOptions = route.pathToRegexpOptions || {};
1161 |   var normalizedPath = normalizePath(
1162 |     path,
1163 |     parent,
1164 |     pathToRegexpOptions.strict
1165 |   );
1166 | 
1167 |   if (typeof route.caseSensitive === 'boolean') {
1168 |     pathToRegexpOptions.sensitive = route.caseSensitive;
1169 |   }
1170 | 
1171 |   var record = {
1172 |     path: normalizedPath,
1173 |     regex: compileRouteRegex(normalizedPath, pathToRegexpOptions),
1174 |     components: route.components || { default: route.component },
1175 |     instances: {},
1176 |     name: name,
1177 |     parent: parent,
1178 |     matchAs: matchAs,
1179 |     redirect: route.redirect,
1180 |     beforeEnter: route.beforeEnter,
1181 |     meta: route.meta || {},
1182 |     props: route.props == null
1183 |       ? {}
1184 |       : route.components
1185 |         ? route.props
1186 |         : { default: route.props }
1187 |   };
1188 | 
1189 |   if (route.children) {
1190 |     // Warn if route is named, does not redirect and has a default child route.
1191 |     // If users navigate to this route by name, the default child will
1192 |     // not be rendered (GH Issue #629)
1193 |     {
1194 |       if (route.name && !route.redirect && route.children.some(function (child) { return /^\/?$/.test(child.path); })) {
1195 |         warn(
1196 |           false,
1197 |           "Named Route '" + (route.name) + "' has a default child route. " +
1198 |           "When navigating to this named route (:to=\"{name: '" + (route.name) + "'\"), " +
1199 |           "the default child route will not be rendered. Remove the name from " +
1200 |           "this route and use the name of the default child route for named " +
1201 |           "links instead."
1202 |         );
1203 |       }
1204 |     }
1205 |     route.children.forEach(function (child) {
1206 |       var childMatchAs = matchAs
1207 |         ? cleanPath((matchAs + "/" + (child.path)))
1208 |         : undefined;
1209 |       addRouteRecord(pathList, pathMap, nameMap, child, record, childMatchAs);
1210 |     });
1211 |   }
1212 | 
1213 |   if (route.alias !== undefined) {
1214 |     var aliases = Array.isArray(route.alias)
1215 |       ? route.alias
1216 |       : [route.alias];
1217 | 
1218 |     aliases.forEach(function (alias) {
1219 |       var aliasRoute = {
1220 |         path: alias,
1221 |         children: route.children
1222 |       };
1223 |       addRouteRecord(
1224 |         pathList,
1225 |         pathMap,
1226 |         nameMap,
1227 |         aliasRoute,
1228 |         parent,
1229 |         record.path || '/' // matchAs
1230 |       );
1231 |     });
1232 |   }
1233 | 
1234 |   if (!pathMap[record.path]) {
1235 |     pathList.push(record.path);
1236 |     pathMap[record.path] = record;
1237 |   }
1238 | 
1239 |   if (name) {
1240 |     if (!nameMap[name]) {
1241 |       nameMap[name] = record;
1242 |     } else if ("development" !== 'production' && !matchAs) {
1243 |       warn(
1244 |         false,
1245 |         "Duplicate named routes definition: " +
1246 |         "{ name: \"" + name + "\", path: \"" + (record.path) + "\" }"
1247 |       );
1248 |     }
1249 |   }
1250 | }
1251 | 
1252 | function compileRouteRegex (path, pathToRegexpOptions) {
1253 |   var regex = pathToRegexp_1(path, [], pathToRegexpOptions);
1254 |   {
1255 |     var keys = Object.create(null);
1256 |     regex.keys.forEach(function (key) {
1257 |       warn(!keys[key.name], ("Duplicate param keys in route with path: \"" + path + "\""));
1258 |       keys[key.name] = true;
1259 |     });
1260 |   }
1261 |   return regex
1262 | }
1263 | 
1264 | function normalizePath (path, parent, strict) {
1265 |   if (!strict) { path = path.replace(/\/$/, ''); }
1266 |   if (path[0] === '/') { return path }
1267 |   if (parent == null) { return path }
1268 |   return cleanPath(((parent.path) + "/" + path))
1269 | }
1270 | 
1271 | /*  */
1272 | 
1273 | 
1274 | function normalizeLocation (
1275 |   raw,
1276 |   current,
1277 |   append,
1278 |   router
1279 | ) {
1280 |   var next = typeof raw === 'string' ? { path: raw } : raw;
1281 |   // named target
1282 |   if (next.name || next._normalized) {
1283 |     return next
1284 |   }
1285 | 
1286 |   // relative params
1287 |   if (!next.path && next.params && current) {
1288 |     next = assign({}, next);
1289 |     next._normalized = true;
1290 |     var params = assign(assign({}, current.params), next.params);
1291 |     if (current.name) {
1292 |       next.name = current.name;
1293 |       next.params = params;
1294 |     } else if (current.matched.length) {
1295 |       var rawPath = current.matched[current.matched.length - 1].path;
1296 |       next.path = fillParams(rawPath, params, ("path " + (current.path)));
1297 |     } else {
1298 |       warn(false, "relative params navigation requires a current route.");
1299 |     }
1300 |     return next
1301 |   }
1302 | 
1303 |   var parsedPath = parsePath(next.path || '');
1304 |   var basePath = (current && current.path) || '/';
1305 |   var path = parsedPath.path
1306 |     ? resolvePath(parsedPath.path, basePath, append || next.append)
1307 |     : basePath;
1308 | 
1309 |   var query = resolveQuery(
1310 |     parsedPath.query,
1311 |     next.query,
1312 |     router && router.options.parseQuery
1313 |   );
1314 | 
1315 |   var hash = next.hash || parsedPath.hash;
1316 |   if (hash && hash.charAt(0) !== '#') {
1317 |     hash = "#" + hash;
1318 |   }
1319 | 
1320 |   return {
1321 |     _normalized: true,
1322 |     path: path,
1323 |     query: query,
1324 |     hash: hash
1325 |   }
1326 | }
1327 | 
1328 | function assign (a, b) {
1329 |   for (var key in b) {
1330 |     a[key] = b[key];
1331 |   }
1332 |   return a
1333 | }
1334 | 
1335 | /*  */
1336 | 
1337 | 
1338 | function createMatcher (
1339 |   routes,
1340 |   router
1341 | ) {
1342 |   var ref = createRouteMap(routes);
1343 |   var pathList = ref.pathList;
1344 |   var pathMap = ref.pathMap;
1345 |   var nameMap = ref.nameMap;
1346 | 
1347 |   function addRoutes (routes) {
1348 |     createRouteMap(routes, pathList, pathMap, nameMap);
1349 |   }
1350 | 
1351 |   function match (
1352 |     raw,
1353 |     currentRoute,
1354 |     redirectedFrom
1355 |   ) {
1356 |     var location = normalizeLocation(raw, currentRoute, false, router);
1357 |     var name = location.name;
1358 | 
1359 |     if (name) {
1360 |       var record = nameMap[name];
1361 |       {
1362 |         warn(record, ("Route with name '" + name + "' does not exist"));
1363 |       }
1364 |       if (!record) { return _createRoute(null, location) }
1365 |       var paramNames = record.regex.keys
1366 |         .filter(function (key) { return !key.optional; })
1367 |         .map(function (key) { return key.name; });
1368 | 
1369 |       if (typeof location.params !== 'object') {
1370 |         location.params = {};
1371 |       }
1372 | 
1373 |       if (currentRoute && typeof currentRoute.params === 'object') {
1374 |         for (var key in currentRoute.params) {
1375 |           if (!(key in location.params) && paramNames.indexOf(key) > -1) {
1376 |             location.params[key] = currentRoute.params[key];
1377 |           }
1378 |         }
1379 |       }
1380 | 
1381 |       if (record) {
1382 |         location.path = fillParams(record.path, location.params, ("named route \"" + name + "\""));
1383 |         return _createRoute(record, location, redirectedFrom)
1384 |       }
1385 |     } else if (location.path) {
1386 |       location.params = {};
1387 |       for (var i = 0; i < pathList.length; i++) {
1388 |         var path = pathList[i];
1389 |         var record$1 = pathMap[path];
1390 |         if (matchRoute(record$1.regex, location.path, location.params)) {
1391 |           return _createRoute(record$1, location, redirectedFrom)
1392 |         }
1393 |       }
1394 |     }
1395 |     // no match
1396 |     return _createRoute(null, location)
1397 |   }
1398 | 
1399 |   function redirect (
1400 |     record,
1401 |     location
1402 |   ) {
1403 |     var originalRedirect = record.redirect;
1404 |     var redirect = typeof originalRedirect === 'function'
1405 |         ? originalRedirect(createRoute(record, location, null, router))
1406 |         : originalRedirect;
1407 | 
1408 |     if (typeof redirect === 'string') {
1409 |       redirect = { path: redirect };
1410 |     }
1411 | 
1412 |     if (!redirect || typeof redirect !== 'object') {
1413 |       {
1414 |         warn(
1415 |           false, ("invalid redirect option: " + (JSON.stringify(redirect)))
1416 |         );
1417 |       }
1418 |       return _createRoute(null, location)
1419 |     }
1420 | 
1421 |     var re = redirect;
1422 |     var name = re.name;
1423 |     var path = re.path;
1424 |     var query = location.query;
1425 |     var hash = location.hash;
1426 |     var params = location.params;
1427 |     query = re.hasOwnProperty('query') ? re.query : query;
1428 |     hash = re.hasOwnProperty('hash') ? re.hash : hash;
1429 |     params = re.hasOwnProperty('params') ? re.params : params;
1430 | 
1431 |     if (name) {
1432 |       // resolved named direct
1433 |       var targetRecord = nameMap[name];
1434 |       {
1435 |         assert(targetRecord, ("redirect failed: named route \"" + name + "\" not found."));
1436 |       }
1437 |       return match({
1438 |         _normalized: true,
1439 |         name: name,
1440 |         query: query,
1441 |         hash: hash,
1442 |         params: params
1443 |       }, undefined, location)
1444 |     } else if (path) {
1445 |       // 1. resolve relative redirect
1446 |       var rawPath = resolveRecordPath(path, record);
1447 |       // 2. resolve params
1448 |       var resolvedPath = fillParams(rawPath, params, ("redirect route with path \"" + rawPath + "\""));
1449 |       // 3. rematch with existing query and hash
1450 |       return match({
1451 |         _normalized: true,
1452 |         path: resolvedPath,
1453 |         query: query,
1454 |         hash: hash
1455 |       }, undefined, location)
1456 |     } else {
1457 |       {
1458 |         warn(false, ("invalid redirect option: " + (JSON.stringify(redirect))));
1459 |       }
1460 |       return _createRoute(null, location)
1461 |     }
1462 |   }
1463 | 
1464 |   function alias (
1465 |     record,
1466 |     location,
1467 |     matchAs
1468 |   ) {
1469 |     var aliasedPath = fillParams(matchAs, location.params, ("aliased route with path \"" + matchAs + "\""));
1470 |     var aliasedMatch = match({
1471 |       _normalized: true,
1472 |       path: aliasedPath
1473 |     });
1474 |     if (aliasedMatch) {
1475 |       var matched = aliasedMatch.matched;
1476 |       var aliasedRecord = matched[matched.length - 1];
1477 |       location.params = aliasedMatch.params;
1478 |       return _createRoute(aliasedRecord, location)
1479 |     }
1480 |     return _createRoute(null, location)
1481 |   }
1482 | 
1483 |   function _createRoute (
1484 |     record,
1485 |     location,
1486 |     redirectedFrom
1487 |   ) {
1488 |     if (record && record.redirect) {
1489 |       return redirect(record, redirectedFrom || location)
1490 |     }
1491 |     if (record && record.matchAs) {
1492 |       return alias(record, location, record.matchAs)
1493 |     }
1494 |     return createRoute(record, location, redirectedFrom, router)
1495 |   }
1496 | 
1497 |   return {
1498 |     match: match,
1499 |     addRoutes: addRoutes
1500 |   }
1501 | }
1502 | 
1503 | function matchRoute (
1504 |   regex,
1505 |   path,
1506 |   params
1507 | ) {
1508 |   var m = path.match(regex);
1509 | 
1510 |   if (!m) {
1511 |     return false
1512 |   } else if (!params) {
1513 |     return true
1514 |   }
1515 | 
1516 |   for (var i = 1, len = m.length; i < len; ++i) {
1517 |     var key = regex.keys[i - 1];
1518 |     var val = typeof m[i] === 'string' ? decodeURIComponent(m[i]) : m[i];
1519 |     if (key) {
1520 |       params[key.name] = val;
1521 |     }
1522 |   }
1523 | 
1524 |   return true
1525 | }
1526 | 
1527 | function resolveRecordPath (path, record) {
1528 |   return resolvePath(path, record.parent ? record.parent.path : '/', true)
1529 | }
1530 | 
1531 | /*  */
1532 | 
1533 | 
1534 | var positionStore = Object.create(null);
1535 | 
1536 | function setupScroll () {
1537 |   // Fix for #1585 for Firefox
1538 |   window.history.replaceState({ key: getStateKey() }, '');
1539 |   window.addEventListener('popstate', function (e) {
1540 |     saveScrollPosition();
1541 |     if (e.state && e.state.key) {
1542 |       setStateKey(e.state.key);
1543 |     }
1544 |   });
1545 | }
1546 | 
1547 | function handleScroll (
1548 |   router,
1549 |   to,
1550 |   from,
1551 |   isPop
1552 | ) {
1553 |   if (!router.app) {
1554 |     return
1555 |   }
1556 | 
1557 |   var behavior = router.options.scrollBehavior;
1558 |   if (!behavior) {
1559 |     return
1560 |   }
1561 | 
1562 |   {
1563 |     assert(typeof behavior === 'function', "scrollBehavior must be a function");
1564 |   }
1565 | 
1566 |   // wait until re-render finishes before scrolling
1567 |   router.app.$nextTick(function () {
1568 |     var position = getScrollPosition();
1569 |     var shouldScroll = behavior(to, from, isPop ? position : null);
1570 | 
1571 |     if (!shouldScroll) {
1572 |       return
1573 |     }
1574 | 
1575 |     if (typeof shouldScroll.then === 'function') {
1576 |       shouldScroll.then(function (shouldScroll) {
1577 |         scrollToPosition((shouldScroll), position);
1578 |       }).catch(function (err) {
1579 |         {
1580 |           assert(false, err.toString());
1581 |         }
1582 |       });
1583 |     } else {
1584 |       scrollToPosition(shouldScroll, position);
1585 |     }
1586 |   });
1587 | }
1588 | 
1589 | function saveScrollPosition () {
1590 |   var key = getStateKey();
1591 |   if (key) {
1592 |     positionStore[key] = {
1593 |       x: window.pageXOffset,
1594 |       y: window.pageYOffset
1595 |     };
1596 |   }
1597 | }
1598 | 
1599 | function getScrollPosition () {
1600 |   var key = getStateKey();
1601 |   if (key) {
1602 |     return positionStore[key]
1603 |   }
1604 | }
1605 | 
1606 | function getElementPosition (el, offset) {
1607 |   var docEl = document.documentElement;
1608 |   var docRect = docEl.getBoundingClientRect();
1609 |   var elRect = el.getBoundingClientRect();
1610 |   return {
1611 |     x: elRect.left - docRect.left - offset.x,
1612 |     y: elRect.top - docRect.top - offset.y
1613 |   }
1614 | }
1615 | 
1616 | function isValidPosition (obj) {
1617 |   return isNumber(obj.x) || isNumber(obj.y)
1618 | }
1619 | 
1620 | function normalizePosition (obj) {
1621 |   return {
1622 |     x: isNumber(obj.x) ? obj.x : window.pageXOffset,
1623 |     y: isNumber(obj.y) ? obj.y : window.pageYOffset
1624 |   }
1625 | }
1626 | 
1627 | function normalizeOffset (obj) {
1628 |   return {
1629 |     x: isNumber(obj.x) ? obj.x : 0,
1630 |     y: isNumber(obj.y) ? obj.y : 0
1631 |   }
1632 | }
1633 | 
1634 | function isNumber (v) {
1635 |   return typeof v === 'number'
1636 | }
1637 | 
1638 | function scrollToPosition (shouldScroll, position) {
1639 |   var isObject = typeof shouldScroll === 'object';
1640 |   if (isObject && typeof shouldScroll.selector === 'string') {
1641 |     var el = document.querySelector(shouldScroll.selector);
1642 |     if (el) {
1643 |       var offset = shouldScroll.offset && typeof shouldScroll.offset === 'object' ? shouldScroll.offset : {};
1644 |       offset = normalizeOffset(offset);
1645 |       position = getElementPosition(el, offset);
1646 |     } else if (isValidPosition(shouldScroll)) {
1647 |       position = normalizePosition(shouldScroll);
1648 |     }
1649 |   } else if (isObject && isValidPosition(shouldScroll)) {
1650 |     position = normalizePosition(shouldScroll);
1651 |   }
1652 | 
1653 |   if (position) {
1654 |     window.scrollTo(position.x, position.y);
1655 |   }
1656 | }
1657 | 
1658 | /*  */
1659 | 
1660 | var supportsPushState = inBrowser && (function () {
1661 |   var ua = window.navigator.userAgent;
1662 | 
1663 |   if (
1664 |     (ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) &&
1665 |     ua.indexOf('Mobile Safari') !== -1 &&
1666 |     ua.indexOf('Chrome') === -1 &&
1667 |     ua.indexOf('Windows Phone') === -1
1668 |   ) {
1669 |     return false
1670 |   }
1671 | 
1672 |   return window.history && 'pushState' in window.history
1673 | })();
1674 | 
1675 | // use User Timing api (if present) for more accurate key precision
1676 | var Time = inBrowser && window.performance && window.performance.now
1677 |   ? window.performance
1678 |   : Date;
1679 | 
1680 | var _key = genKey();
1681 | 
1682 | function genKey () {
1683 |   return Time.now().toFixed(3)
1684 | }
1685 | 
1686 | function getStateKey () {
1687 |   return _key
1688 | }
1689 | 
1690 | function setStateKey (key) {
1691 |   _key = key;
1692 | }
1693 | 
1694 | function pushState (url, replace) {
1695 |   saveScrollPosition();
1696 |   // try...catch the pushState call to get around Safari
1697 |   // DOM Exception 18 where it limits to 100 pushState calls
1698 |   var history = window.history;
1699 |   try {
1700 |     if (replace) {
1701 |       history.replaceState({ key: _key }, '', url);
1702 |     } else {
1703 |       _key = genKey();
1704 |       history.pushState({ key: _key }, '', url);
1705 |     }
1706 |   } catch (e) {
1707 |     window.location[replace ? 'replace' : 'assign'](url);
1708 |   }
1709 | }
1710 | 
1711 | function replaceState (url) {
1712 |   pushState(url, true);
1713 | }
1714 | 
1715 | /*  */
1716 | 
1717 | function runQueue (queue, fn, cb) {
1718 |   var step = function (index) {
1719 |     if (index >= queue.length) {
1720 |       cb();
1721 |     } else {
1722 |       if (queue[index]) {
1723 |         fn(queue[index], function () {
1724 |           step(index + 1);
1725 |         });
1726 |       } else {
1727 |         step(index + 1);
1728 |       }
1729 |     }
1730 |   };
1731 |   step(0);
1732 | }
1733 | 
1734 | /*  */
1735 | 
1736 | function resolveAsyncComponents (matched) {
1737 |   return function (to, from, next) {
1738 |     var hasAsync = false;
1739 |     var pending = 0;
1740 |     var error = null;
1741 | 
1742 |     flatMapComponents(matched, function (def, _, match, key) {
1743 |       // if it's a function and doesn't have cid attached,
1744 |       // assume it's an async component resolve function.
1745 |       // we are not using Vue's default async resolving mechanism because
1746 |       // we want to halt the navigation until the incoming component has been
1747 |       // resolved.
1748 |       if (typeof def === 'function' && def.cid === undefined) {
1749 |         hasAsync = true;
1750 |         pending++;
1751 | 
1752 |         var resolve = once(function (resolvedDef) {
1753 |           if (isESModule(resolvedDef)) {
1754 |             resolvedDef = resolvedDef.default;
1755 |           }
1756 |           // save resolved on async factory in case it's used elsewhere
1757 |           def.resolved = typeof resolvedDef === 'function'
1758 |             ? resolvedDef
1759 |             : _Vue.extend(resolvedDef);
1760 |           match.components[key] = resolvedDef;
1761 |           pending--;
1762 |           if (pending <= 0) {
1763 |             next();
1764 |           }
1765 |         });
1766 | 
1767 |         var reject = once(function (reason) {
1768 |           var msg = "Failed to resolve async component " + key + ": " + reason;
1769 |           "development" !== 'production' && warn(false, msg);
1770 |           if (!error) {
1771 |             error = isError(reason)
1772 |               ? reason
1773 |               : new Error(msg);
1774 |             next(error);
1775 |           }
1776 |         });
1777 | 
1778 |         var res;
1779 |         try {
1780 |           res = def(resolve, reject);
1781 |         } catch (e) {
1782 |           reject(e);
1783 |         }
1784 |         if (res) {
1785 |           if (typeof res.then === 'function') {
1786 |             res.then(resolve, reject);
1787 |           } else {
1788 |             // new syntax in Vue 2.3
1789 |             var comp = res.component;
1790 |             if (comp && typeof comp.then === 'function') {
1791 |               comp.then(resolve, reject);
1792 |             }
1793 |           }
1794 |         }
1795 |       }
1796 |     });
1797 | 
1798 |     if (!hasAsync) { next(); }
1799 |   }
1800 | }
1801 | 
1802 | function flatMapComponents (
1803 |   matched,
1804 |   fn
1805 | ) {
1806 |   return flatten(matched.map(function (m) {
1807 |     return Object.keys(m.components).map(function (key) { return fn(
1808 |       m.components[key],
1809 |       m.instances[key],
1810 |       m, key
1811 |     ); })
1812 |   }))
1813 | }
1814 | 
1815 | function flatten (arr) {
1816 |   return Array.prototype.concat.apply([], arr)
1817 | }
1818 | 
1819 | var hasSymbol =
1820 |   typeof Symbol === 'function' &&
1821 |   typeof Symbol.toStringTag === 'symbol';
1822 | 
1823 | function isESModule (obj) {
1824 |   return obj.__esModule || (hasSymbol && obj[Symbol.toStringTag] === 'Module')
1825 | }
1826 | 
1827 | // in Webpack 2, require.ensure now also returns a Promise
1828 | // so the resolve/reject functions may get called an extra time
1829 | // if the user uses an arrow function shorthand that happens to
1830 | // return that Promise.
1831 | function once (fn) {
1832 |   var called = false;
1833 |   return function () {
1834 |     var args = [], len = arguments.length;
1835 |     while ( len-- ) args[ len ] = arguments[ len ];
1836 | 
1837 |     if (called) { return }
1838 |     called = true;
1839 |     return fn.apply(this, args)
1840 |   }
1841 | }
1842 | 
1843 | /*  */
1844 | 
1845 | var History = function History (router, base) {
1846 |   this.router = router;
1847 |   this.base = normalizeBase(base);
1848 |   // start with a route object that stands for "nowhere"
1849 |   this.current = START;
1850 |   this.pending = null;
1851 |   this.ready = false;
1852 |   this.readyCbs = [];
1853 |   this.readyErrorCbs = [];
1854 |   this.errorCbs = [];
1855 | };
1856 | 
1857 | History.prototype.listen = function listen (cb) {
1858 |   this.cb = cb;
1859 | };
1860 | 
1861 | History.prototype.onReady = function onReady (cb, errorCb) {
1862 |   if (this.ready) {
1863 |     cb();
1864 |   } else {
1865 |     this.readyCbs.push(cb);
1866 |     if (errorCb) {
1867 |       this.readyErrorCbs.push(errorCb);
1868 |     }
1869 |   }
1870 | };
1871 | 
1872 | History.prototype.onError = function onError (errorCb) {
1873 |   this.errorCbs.push(errorCb);
1874 | };
1875 | 
1876 | History.prototype.transitionTo = function transitionTo (location, onComplete, onAbort) {
1877 |     var this$1 = this;
1878 | 
1879 |   var route = this.router.match(location, this.current);
1880 |   this.confirmTransition(route, function () {
1881 |     this$1.updateRoute(route);
1882 |     onComplete && onComplete(route);
1883 |     this$1.ensureURL();
1884 | 
1885 |     // fire ready cbs once
1886 |     if (!this$1.ready) {
1887 |       this$1.ready = true;
1888 |       this$1.readyCbs.forEach(function (cb) { cb(route); });
1889 |     }
1890 |   }, function (err) {
1891 |     if (onAbort) {
1892 |       onAbort(err);
1893 |     }
1894 |     if (err && !this$1.ready) {
1895 |       this$1.ready = true;
1896 |       this$1.readyErrorCbs.forEach(function (cb) { cb(err); });
1897 |     }
1898 |   });
1899 | };
1900 | 
1901 | History.prototype.confirmTransition = function confirmTransition (route, onComplete, onAbort) {
1902 |     var this$1 = this;
1903 | 
1904 |   var current = this.current;
1905 |   var abort = function (err) {
1906 |     if (isError(err)) {
1907 |       if (this$1.errorCbs.length) {
1908 |         this$1.errorCbs.forEach(function (cb) { cb(err); });
1909 |       } else {
1910 |         warn(false, 'uncaught error during route navigation:');
1911 |         console.error(err);
1912 |       }
1913 |     }
1914 |     onAbort && onAbort(err);
1915 |   };
1916 |   if (
1917 |     isSameRoute(route, current) &&
1918 |     // in the case the route map has been dynamically appended to
1919 |     route.matched.length === current.matched.length
1920 |   ) {
1921 |     this.ensureURL();
1922 |     return abort()
1923 |   }
1924 | 
1925 |   var ref = resolveQueue(this.current.matched, route.matched);
1926 |     var updated = ref.updated;
1927 |     var deactivated = ref.deactivated;
1928 |     var activated = ref.activated;
1929 | 
1930 |   var queue = [].concat(
1931 |     // in-component leave guards
1932 |     extractLeaveGuards(deactivated),
1933 |     // global before hooks
1934 |     this.router.beforeHooks,
1935 |     // in-component update hooks
1936 |     extractUpdateHooks(updated),
1937 |     // in-config enter guards
1938 |     activated.map(function (m) { return m.beforeEnter; }),
1939 |     // async components
1940 |     resolveAsyncComponents(activated)
1941 |   );
1942 | 
1943 |   this.pending = route;
1944 |   var iterator = function (hook, next) {
1945 |     if (this$1.pending !== route) {
1946 |       return abort()
1947 |     }
1948 |     try {
1949 |       hook(route, current, function (to) {
1950 |         if (to === false || isError(to)) {
1951 |           // next(false) -> abort navigation, ensure current URL
1952 |           this$1.ensureURL(true);
1953 |           abort(to);
1954 |         } else if (
1955 |           typeof to === 'string' ||
1956 |           (typeof to === 'object' && (
1957 |             typeof to.path === 'string' ||
1958 |             typeof to.name === 'string'
1959 |           ))
1960 |         ) {
1961 |           // next('/') or next({ path: '/' }) -> redirect
1962 |           abort();
1963 |           if (typeof to === 'object' && to.replace) {
1964 |             this$1.replace(to);
1965 |           } else {
1966 |             this$1.push(to);
1967 |           }
1968 |         } else {
1969 |           // confirm transition and pass on the value
1970 |           next(to);
1971 |         }
1972 |       });
1973 |     } catch (e) {
1974 |       abort(e);
1975 |     }
1976 |   };
1977 | 
1978 |   runQueue(queue, iterator, function () {
1979 |     var postEnterCbs = [];
1980 |     var isValid = function () { return this$1.current === route; };
1981 |     // wait until async components are resolved before
1982 |     // extracting in-component enter guards
1983 |     var enterGuards = extractEnterGuards(activated, postEnterCbs, isValid);
1984 |     var queue = enterGuards.concat(this$1.router.resolveHooks);
1985 |     runQueue(queue, iterator, function () {
1986 |       if (this$1.pending !== route) {
1987 |         return abort()
1988 |       }
1989 |       this$1.pending = null;
1990 |       onComplete(route);
1991 |       if (this$1.router.app) {
1992 |         this$1.router.app.$nextTick(function () {
1993 |           postEnterCbs.forEach(function (cb) { cb(); });
1994 |         });
1995 |       }
1996 |     });
1997 |   });
1998 | };
1999 | 
2000 | History.prototype.updateRoute = function updateRoute (route) {
2001 |   var prev = this.current;
2002 |   this.current = route;
2003 |   this.cb && this.cb(route);
2004 |   this.router.afterHooks.forEach(function (hook) {
2005 |     hook && hook(route, prev);
2006 |   });
2007 | };
2008 | 
2009 | function normalizeBase (base) {
2010 |   if (!base) {
2011 |     if (inBrowser) {
2012 |       // respect <base> tag
2013 |       var baseEl = document.querySelector('base');
2014 |       base = (baseEl && baseEl.getAttribute('href')) || '/';
2015 |       // strip full URL origin
2016 |       base = base.replace(/^https?:\/\/[^\/]+/, '');
2017 |     } else {
2018 |       base = '/';
2019 |     }
2020 |   }
2021 |   // make sure there's the starting slash
2022 |   if (base.charAt(0) !== '/') {
2023 |     base = '/' + base;
2024 |   }
2025 |   // remove trailing slash
2026 |   return base.replace(/\/$/, '')
2027 | }
2028 | 
2029 | function resolveQueue (
2030 |   current,
2031 |   next
2032 | ) {
2033 |   var i;
2034 |   var max = Math.max(current.length, next.length);
2035 |   for (i = 0; i < max; i++) {
2036 |     if (current[i] !== next[i]) {
2037 |       break
2038 |     }
2039 |   }
2040 |   return {
2041 |     updated: next.slice(0, i),
2042 |     activated: next.slice(i),
2043 |     deactivated: current.slice(i)
2044 |   }
2045 | }
2046 | 
2047 | function extractGuards (
2048 |   records,
2049 |   name,
2050 |   bind,
2051 |   reverse
2052 | ) {
2053 |   var guards = flatMapComponents(records, function (def, instance, match, key) {
2054 |     var guard = extractGuard(def, name);
2055 |     if (guard) {
2056 |       return Array.isArray(guard)
2057 |         ? guard.map(function (guard) { return bind(guard, instance, match, key); })
2058 |         : bind(guard, instance, match, key)
2059 |     }
2060 |   });
2061 |   return flatten(reverse ? guards.reverse() : guards)
2062 | }
2063 | 
2064 | function extractGuard (
2065 |   def,
2066 |   key
2067 | ) {
2068 |   if (typeof def !== 'function') {
2069 |     // extend now so that global mixins are applied.
2070 |     def = _Vue.extend(def);
2071 |   }
2072 |   return def.options[key]
2073 | }
2074 | 
2075 | function extractLeaveGuards (deactivated) {
2076 |   return extractGuards(deactivated, 'beforeRouteLeave', bindGuard, true)
2077 | }
2078 | 
2079 | function extractUpdateHooks (updated) {
2080 |   return extractGuards(updated, 'beforeRouteUpdate', bindGuard)
2081 | }
2082 | 
2083 | function bindGuard (guard, instance) {
2084 |   if (instance) {
2085 |     return function boundRouteGuard () {
2086 |       return guard.apply(instance, arguments)
2087 |     }
2088 |   }
2089 | }
2090 | 
2091 | function extractEnterGuards (
2092 |   activated,
2093 |   cbs,
2094 |   isValid
2095 | ) {
2096 |   return extractGuards(activated, 'beforeRouteEnter', function (guard, _, match, key) {
2097 |     return bindEnterGuard(guard, match, key, cbs, isValid)
2098 |   })
2099 | }
2100 | 
2101 | function bindEnterGuard (
2102 |   guard,
2103 |   match,
2104 |   key,
2105 |   cbs,
2106 |   isValid
2107 | ) {
2108 |   return function routeEnterGuard (to, from, next) {
2109 |     return guard(to, from, function (cb) {
2110 |       next(cb);
2111 |       if (typeof cb === 'function') {
2112 |         cbs.push(function () {
2113 |           // #750
2114 |           // if a router-view is wrapped with an out-in transition,
2115 |           // the instance may not have been registered at this time.
2116 |           // we will need to poll for registration until current route
2117 |           // is no longer valid.
2118 |           poll(cb, match.instances, key, isValid);
2119 |         });
2120 |       }
2121 |     })
2122 |   }
2123 | }
2124 | 
2125 | function poll (
2126 |   cb, // somehow flow cannot infer this is a function
2127 |   instances,
2128 |   key,
2129 |   isValid
2130 | ) {
2131 |   if (instances[key]) {
2132 |     cb(instances[key]);
2133 |   } else if (isValid()) {
2134 |     setTimeout(function () {
2135 |       poll(cb, instances, key, isValid);
2136 |     }, 16);
2137 |   }
2138 | }
2139 | 
2140 | /*  */
2141 | 
2142 | 
2143 | var HTML5History = (function (History$$1) {
2144 |   function HTML5History (router, base) {
2145 |     var this$1 = this;
2146 | 
2147 |     History$$1.call(this, router, base);
2148 | 
2149 |     var expectScroll = router.options.scrollBehavior;
2150 | 
2151 |     if (expectScroll) {
2152 |       setupScroll();
2153 |     }
2154 | 
2155 |     var initLocation = getLocation(this.base);
2156 |     window.addEventListener('popstate', function (e) {
2157 |       var current = this$1.current;
2158 | 
2159 |       // Avoiding first `popstate` event dispatched in some browsers but first
2160 |       // history route not updated since async guard at the same time.
2161 |       var location = getLocation(this$1.base);
2162 |       if (this$1.current === START && location === initLocation) {
2163 |         return
2164 |       }
2165 | 
2166 |       this$1.transitionTo(location, function (route) {
2167 |         if (expectScroll) {
2168 |           handleScroll(router, route, current, true);
2169 |         }
2170 |       });
2171 |     });
2172 |   }
2173 | 
2174 |   if ( History$$1 ) HTML5History.__proto__ = History$$1;
2175 |   HTML5History.prototype = Object.create( History$$1 && History$$1.prototype );
2176 |   HTML5History.prototype.constructor = HTML5History;
2177 | 
2178 |   HTML5History.prototype.go = function go (n) {
2179 |     window.history.go(n);
2180 |   };
2181 | 
2182 |   HTML5History.prototype.push = function push (location, onComplete, onAbort) {
2183 |     var this$1 = this;
2184 | 
2185 |     var ref = this;
2186 |     var fromRoute = ref.current;
2187 |     this.transitionTo(location, function (route) {
2188 |       pushState(cleanPath(this$1.base + route.fullPath));
2189 |       handleScroll(this$1.router, route, fromRoute, false);
2190 |       onComplete && onComplete(route);
2191 |     }, onAbort);
2192 |   };
2193 | 
2194 |   HTML5History.prototype.replace = function replace (location, onComplete, onAbort) {
2195 |     var this$1 = this;
2196 | 
2197 |     var ref = this;
2198 |     var fromRoute = ref.current;
2199 |     this.transitionTo(location, function (route) {
2200 |       replaceState(cleanPath(this$1.base + route.fullPath));
2201 |       handleScroll(this$1.router, route, fromRoute, false);
2202 |       onComplete && onComplete(route);
2203 |     }, onAbort);
2204 |   };
2205 | 
2206 |   HTML5History.prototype.ensureURL = function ensureURL (push) {
2207 |     if (getLocation(this.base) !== this.current.fullPath) {
2208 |       var current = cleanPath(this.base + this.current.fullPath);
2209 |       push ? pushState(current) : replaceState(current);
2210 |     }
2211 |   };
2212 | 
2213 |   HTML5History.prototype.getCurrentLocation = function getCurrentLocation () {
2214 |     return getLocation(this.base)
2215 |   };
2216 | 
2217 |   return HTML5History;
2218 | }(History));
2219 | 
2220 | function getLocation (base) {
2221 |   var path = window.location.pathname;
2222 |   if (base && path.indexOf(base) === 0) {
2223 |     path = path.slice(base.length);
2224 |   }
2225 |   return (path || '/') + window.location.search + window.location.hash
2226 | }
2227 | 
2228 | /*  */
2229 | 
2230 | 
2231 | var HashHistory = (function (History$$1) {
2232 |   function HashHistory (router, base, fallback) {
2233 |     History$$1.call(this, router, base);
2234 |     // check history fallback deeplinking
2235 |     if (fallback && checkFallback(this.base)) {
2236 |       return
2237 |     }
2238 |     ensureSlash();
2239 |   }
2240 | 
2241 |   if ( History$$1 ) HashHistory.__proto__ = History$$1;
2242 |   HashHistory.prototype = Object.create( History$$1 && History$$1.prototype );
2243 |   HashHistory.prototype.constructor = HashHistory;
2244 | 
2245 |   // this is delayed until the app mounts
2246 |   // to avoid the hashchange listener being fired too early
2247 |   HashHistory.prototype.setupListeners = function setupListeners () {
2248 |     var this$1 = this;
2249 | 
2250 |     var router = this.router;
2251 |     var expectScroll = router.options.scrollBehavior;
2252 |     var supportsScroll = supportsPushState && expectScroll;
2253 | 
2254 |     if (supportsScroll) {
2255 |       setupScroll();
2256 |     }
2257 | 
2258 |     window.addEventListener(supportsPushState ? 'popstate' : 'hashchange', function () {
2259 |       var current = this$1.current;
2260 |       if (!ensureSlash()) {
2261 |         return
2262 |       }
2263 |       this$1.transitionTo(getHash(), function (route) {
2264 |         if (supportsScroll) {
2265 |           handleScroll(this$1.router, route, current, true);
2266 |         }
2267 |         if (!supportsPushState) {
2268 |           replaceHash(route.fullPath);
2269 |         }
2270 |       });
2271 |     });
2272 |   };
2273 | 
2274 |   HashHistory.prototype.push = function push (location, onComplete, onAbort) {
2275 |     var this$1 = this;
2276 | 
2277 |     var ref = this;
2278 |     var fromRoute = ref.current;
2279 |     this.transitionTo(location, function (route) {
2280 |       pushHash(route.fullPath);
2281 |       handleScroll(this$1.router, route, fromRoute, false);
2282 |       onComplete && onComplete(route);
2283 |     }, onAbort);
2284 |   };
2285 | 
2286 |   HashHistory.prototype.replace = function replace (location, onComplete, onAbort) {
2287 |     var this$1 = this;
2288 | 
2289 |     var ref = this;
2290 |     var fromRoute = ref.current;
2291 |     this.transitionTo(location, function (route) {
2292 |       replaceHash(route.fullPath);
2293 |       handleScroll(this$1.router, route, fromRoute, false);
2294 |       onComplete && onComplete(route);
2295 |     }, onAbort);
2296 |   };
2297 | 
2298 |   HashHistory.prototype.go = function go (n) {
2299 |     window.history.go(n);
2300 |   };
2301 | 
2302 |   HashHistory.prototype.ensureURL = function ensureURL (push) {
2303 |     var current = this.current.fullPath;
2304 |     if (getHash() !== current) {
2305 |       push ? pushHash(current) : replaceHash(current);
2306 |     }
2307 |   };
2308 | 
2309 |   HashHistory.prototype.getCurrentLocation = function getCurrentLocation () {
2310 |     return getHash()
2311 |   };
2312 | 
2313 |   return HashHistory;
2314 | }(History));
2315 | 
2316 | function checkFallback (base) {
2317 |   var location = getLocation(base);
2318 |   if (!/^\/#/.test(location)) {
2319 |     window.location.replace(
2320 |       cleanPath(base + '/#' + location)
2321 |     );
2322 |     return true
2323 |   }
2324 | }
2325 | 
2326 | function ensureSlash () {
2327 |   var path = getHash();
2328 |   if (path.charAt(0) === '/') {
2329 |     return true
2330 |   }
2331 |   replaceHash('/' + path);
2332 |   return false
2333 | }
2334 | 
2335 | function getHash () {
2336 |   // We can't use window.location.hash here because it's not
2337 |   // consistent across browsers - Firefox will pre-decode it!
2338 |   var href = window.location.href;
2339 |   var index = href.indexOf('#');
2340 |   return index === -1 ? '' : href.slice(index + 1)
2341 | }
2342 | 
2343 | function getUrl (path) {
2344 |   var href = window.location.href;
2345 |   var i = href.indexOf('#');
2346 |   var base = i >= 0 ? href.slice(0, i) : href;
2347 |   return (base + "#" + path)
2348 | }
2349 | 
2350 | function pushHash (path) {
2351 |   if (supportsPushState) {
2352 |     pushState(getUrl(path));
2353 |   } else {
2354 |     window.location.hash = path;
2355 |   }
2356 | }
2357 | 
2358 | function replaceHash (path) {
2359 |   if (supportsPushState) {
2360 |     replaceState(getUrl(path));
2361 |   } else {
2362 |     window.location.replace(getUrl(path));
2363 |   }
2364 | }
2365 | 
2366 | /*  */
2367 | 
2368 | 
2369 | var AbstractHistory = (function (History$$1) {
2370 |   function AbstractHistory (router, base) {
2371 |     History$$1.call(this, router, base);
2372 |     this.stack = [];
2373 |     this.index = -1;
2374 |   }
2375 | 
2376 |   if ( History$$1 ) AbstractHistory.__proto__ = History$$1;
2377 |   AbstractHistory.prototype = Object.create( History$$1 && History$$1.prototype );
2378 |   AbstractHistory.prototype.constructor = AbstractHistory;
2379 | 
2380 |   AbstractHistory.prototype.push = function push (location, onComplete, onAbort) {
2381 |     var this$1 = this;
2382 | 
2383 |     this.transitionTo(location, function (route) {
2384 |       this$1.stack = this$1.stack.slice(0, this$1.index + 1).concat(route);
2385 |       this$1.index++;
2386 |       onComplete && onComplete(route);
2387 |     }, onAbort);
2388 |   };
2389 | 
2390 |   AbstractHistory.prototype.replace = function replace (location, onComplete, onAbort) {
2391 |     var this$1 = this;
2392 | 
2393 |     this.transitionTo(location, function (route) {
2394 |       this$1.stack = this$1.stack.slice(0, this$1.index).concat(route);
2395 |       onComplete && onComplete(route);
2396 |     }, onAbort);
2397 |   };
2398 | 
2399 |   AbstractHistory.prototype.go = function go (n) {
2400 |     var this$1 = this;
2401 | 
2402 |     var targetIndex = this.index + n;
2403 |     if (targetIndex < 0 || targetIndex >= this.stack.length) {
2404 |       return
2405 |     }
2406 |     var route = this.stack[targetIndex];
2407 |     this.confirmTransition(route, function () {
2408 |       this$1.index = targetIndex;
2409 |       this$1.updateRoute(route);
2410 |     });
2411 |   };
2412 | 
2413 |   AbstractHistory.prototype.getCurrentLocation = function getCurrentLocation () {
2414 |     var current = this.stack[this.stack.length - 1];
2415 |     return current ? current.fullPath : '/'
2416 |   };
2417 | 
2418 |   AbstractHistory.prototype.ensureURL = function ensureURL () {
2419 |     // noop
2420 |   };
2421 | 
2422 |   return AbstractHistory;
2423 | }(History));
2424 | 
2425 | /*  */
2426 | 
2427 | var VueRouter = function VueRouter (options) {
2428 |   if ( options === void 0 ) options = {};
2429 | 
2430 |   this.app = null;
2431 |   this.apps = [];
2432 |   this.options = options;
2433 |   this.beforeHooks = [];
2434 |   this.resolveHooks = [];
2435 |   this.afterHooks = [];
2436 |   this.matcher = createMatcher(options.routes || [], this);
2437 | 
2438 |   var mode = options.mode || 'hash';
2439 |   this.fallback = mode === 'history' && !supportsPushState && options.fallback !== false;
2440 |   if (this.fallback) {
2441 |     mode = 'hash';
2442 |   }
2443 |   if (!inBrowser) {
2444 |     mode = 'abstract';
2445 |   }
2446 |   this.mode = mode;
2447 | 
2448 |   switch (mode) {
2449 |     case 'history':
2450 |       this.history = new HTML5History(this, options.base);
2451 |       break
2452 |     case 'hash':
2453 |       this.history = new HashHistory(this, options.base, this.fallback);
2454 |       break
2455 |     case 'abstract':
2456 |       this.history = new AbstractHistory(this, options.base);
2457 |       break
2458 |     default:
2459 |       {
2460 |         assert(false, ("invalid mode: " + mode));
2461 |       }
2462 |   }
2463 | };
2464 | 
2465 | var prototypeAccessors = { currentRoute: { configurable: true } };
2466 | 
2467 | VueRouter.prototype.match = function match (
2468 |   raw,
2469 |   current,
2470 |   redirectedFrom
2471 | ) {
2472 |   return this.matcher.match(raw, current, redirectedFrom)
2473 | };
2474 | 
2475 | prototypeAccessors.currentRoute.get = function () {
2476 |   return this.history && this.history.current
2477 | };
2478 | 
2479 | VueRouter.prototype.init = function init (app /* Vue component instance */) {
2480 |     var this$1 = this;
2481 | 
2482 |   "development" !== 'production' && assert(
2483 |     install.installed,
2484 |     "not installed. Make sure to call `Vue.use(VueRouter)` " +
2485 |     "before creating root instance."
2486 |   );
2487 | 
2488 |   this.apps.push(app);
2489 | 
2490 |   // main app already initialized.
2491 |   if (this.app) {
2492 |     return
2493 |   }
2494 | 
2495 |   this.app = app;
2496 | 
2497 |   var history = this.history;
2498 | 
2499 |   if (history instanceof HTML5History) {
2500 |     history.transitionTo(history.getCurrentLocation());
2501 |   } else if (history instanceof HashHistory) {
2502 |     var setupHashListener = function () {
2503 |       history.setupListeners();
2504 |     };
2505 |     history.transitionTo(
2506 |       history.getCurrentLocation(),
2507 |       setupHashListener,
2508 |       setupHashListener
2509 |     );
2510 |   }
2511 | 
2512 |   history.listen(function (route) {
2513 |     this$1.apps.forEach(function (app) {
2514 |       app._route = route;
2515 |     });
2516 |   });
2517 | };
2518 | 
2519 | VueRouter.prototype.beforeEach = function beforeEach (fn) {
2520 |   return registerHook(this.beforeHooks, fn)
2521 | };
2522 | 
2523 | VueRouter.prototype.beforeResolve = function beforeResolve (fn) {
2524 |   return registerHook(this.resolveHooks, fn)
2525 | };
2526 | 
2527 | VueRouter.prototype.afterEach = function afterEach (fn) {
2528 |   return registerHook(this.afterHooks, fn)
2529 | };
2530 | 
2531 | VueRouter.prototype.onReady = function onReady (cb, errorCb) {
2532 |   this.history.onReady(cb, errorCb);
2533 | };
2534 | 
2535 | VueRouter.prototype.onError = function onError (errorCb) {
2536 |   this.history.onError(errorCb);
2537 | };
2538 | 
2539 | VueRouter.prototype.push = function push (location, onComplete, onAbort) {
2540 |   this.history.push(location, onComplete, onAbort);
2541 | };
2542 | 
2543 | VueRouter.prototype.replace = function replace (location, onComplete, onAbort) {
2544 |   this.history.replace(location, onComplete, onAbort);
2545 | };
2546 | 
2547 | VueRouter.prototype.go = function go (n) {
2548 |   this.history.go(n);
2549 | };
2550 | 
2551 | VueRouter.prototype.back = function back () {
2552 |   this.go(-1);
2553 | };
2554 | 
2555 | VueRouter.prototype.forward = function forward () {
2556 |   this.go(1);
2557 | };
2558 | 
2559 | VueRouter.prototype.getMatchedComponents = function getMatchedComponents (to) {
2560 |   var route = to
2561 |     ? to.matched
2562 |       ? to
2563 |       : this.resolve(to).route
2564 |     : this.currentRoute;
2565 |   if (!route) {
2566 |     return []
2567 |   }
2568 |   return [].concat.apply([], route.matched.map(function (m) {
2569 |     return Object.keys(m.components).map(function (key) {
2570 |       return m.components[key]
2571 |     })
2572 |   }))
2573 | };
2574 | 
2575 | VueRouter.prototype.resolve = function resolve (
2576 |   to,
2577 |   current,
2578 |   append
2579 | ) {
2580 |   var location = normalizeLocation(
2581 |     to,
2582 |     current || this.history.current,
2583 |     append,
2584 |     this
2585 |   );
2586 |   var route = this.match(location, current);
2587 |   var fullPath = route.redirectedFrom || route.fullPath;
2588 |   var base = this.history.base;
2589 |   var href = createHref(base, fullPath, this.mode);
2590 |   return {
2591 |     location: location,
2592 |     route: route,
2593 |     href: href,
2594 |     // for backwards compat
2595 |     normalizedTo: location,
2596 |     resolved: route
2597 |   }
2598 | };
2599 | 
2600 | VueRouter.prototype.addRoutes = function addRoutes (routes) {
2601 |   this.matcher.addRoutes(routes);
2602 |   if (this.history.current !== START) {
2603 |     this.history.transitionTo(this.history.getCurrentLocation());
2604 |   }
2605 | };
2606 | 
2607 | Object.defineProperties( VueRouter.prototype, prototypeAccessors );
2608 | 
2609 | function registerHook (list, fn) {
2610 |   list.push(fn);
2611 |   return function () {
2612 |     var i = list.indexOf(fn);
2613 |     if (i > -1) { list.splice(i, 1); }
2614 |   }
2615 | }
2616 | 
2617 | function createHref (base, fullPath, mode) {
2618 |   var path = mode === 'hash' ? '#' + fullPath : fullPath;
2619 |   return base ? cleanPath(base + '/' + path) : path
2620 | }
2621 | 
2622 | VueRouter.install = install;
2623 | VueRouter.version = '3.0.1';
2624 | 
2625 | if (inBrowser && window.Vue) {
2626 |   window.Vue.use(VueRouter);
2627 | }
2628 | 
2629 | return VueRouter;
2630 | 
2631 | })));
2632 | 


--------------------------------------------------------------------------------
/vendor/assets/javascripts/dist/vue-router.min.js:
--------------------------------------------------------------------------------
1 | /**
2 |   * vue-router v3.0.1
3 |   * (c) 2017 Evan You
4 |   * @license MIT
5 |   */
6 | !function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):t.VueRouter=e()}(this,function(){"use strict";function t(t,e){}function e(t){return Object.prototype.toString.call(t).indexOf("Error")>-1}function r(t,e){switch(typeof e){case"undefined":return;case"object":return e;case"function":return e(t);case"boolean":return e?t.params:void 0}}function n(t,e){for(var r in e)t[r]=e[r];return t}function o(t,e,r){void 0===e&&(e={});var n,o=r||i;try{n=o(t||"")}catch(t){n={}}for(var a in e)n[a]=e[a];return n}function i(t){var e={};return(t=t.trim().replace(/^(\?|#|&)/,""))?(t.split("&").forEach(function(t){var r=t.replace(/\+/g," ").split("="),n=Ut(r.shift()),o=r.length>0?Ut(r.join("=")):null;void 0===e[n]?e[n]=o:Array.isArray(e[n])?e[n].push(o):e[n]=[e[n],o]}),e):e}function a(t){var e=t?Object.keys(t).map(function(e){var r=t[e];if(void 0===r)return"";if(null===r)return Pt(e);if(Array.isArray(r)){var n=[];return r.forEach(function(t){void 0!==t&&(null===t?n.push(Pt(e)):n.push(Pt(e)+"="+Pt(t)))}),n.join("&")}return Pt(e)+"="+Pt(r)}).filter(function(t){return t.length>0}).join("&"):null;return e?"?"+e:""}function u(t,e,r,n){var o=n&&n.options.stringifyQuery,i=e.query||{};try{i=c(i)}catch(t){}var a={name:e.name||t&&t.name,meta:t&&t.meta||{},path:e.path||"/",hash:e.hash||"",query:i,params:e.params||{},fullPath:p(e,o),matched:t?s(t):[]};return r&&(a.redirectedFrom=p(r,o)),Object.freeze(a)}function c(t){if(Array.isArray(t))return t.map(c);if(t&&"object"==typeof t){var e={};for(var r in t)e[r]=c(t[r]);return e}return t}function s(t){for(var e=[];t;)e.unshift(t),t=t.parent;return e}function p(t,e){var r=t.path,n=t.query;void 0===n&&(n={});var o=t.hash;void 0===o&&(o="");var i=e||a;return(r||"/")+i(n)+o}function f(t,e){return e===Ht?t===e:!!e&&(t.path&&e.path?t.path.replace(Mt,"")===e.path.replace(Mt,"")&&t.hash===e.hash&&h(t.query,e.query):!(!t.name||!e.name)&&(t.name===e.name&&t.hash===e.hash&&h(t.query,e.query)&&h(t.params,e.params)))}function h(t,e){if(void 0===t&&(t={}),void 0===e&&(e={}),!t||!e)return t===e;var r=Object.keys(t),n=Object.keys(e);return r.length===n.length&&r.every(function(r){var n=t[r],o=e[r];return"object"==typeof n&&"object"==typeof o?h(n,o):String(n)===String(o)})}function l(t,e){return 0===t.path.replace(Mt,"/").indexOf(e.path.replace(Mt,"/"))&&(!e.hash||t.hash===e.hash)&&d(t.query,e.query)}function d(t,e){for(var r in e)if(!(r in t))return!1;return!0}function y(t){if(!(t.metaKey||t.altKey||t.ctrlKey||t.shiftKey||t.defaultPrevented||void 0!==t.button&&0!==t.button)){if(t.currentTarget&&t.currentTarget.getAttribute){var e=t.currentTarget.getAttribute("target");if(/\b_blank\b/i.test(e))return}return t.preventDefault&&t.preventDefault(),!0}}function v(t){if(t)for(var e,r=0;r<t.length;r++){if("a"===(e=t[r]).tag)return e;if(e.children&&(e=v(e.children)))return e}}function m(t){if(!m.installed||Tt!==t){m.installed=!0,Tt=t;var e=function(t){return void 0!==t},r=function(t,r){var n=t.$options._parentVnode;e(n)&&e(n=n.data)&&e(n=n.registerRouteInstance)&&n(t,r)};t.mixin({beforeCreate:function(){e(this.$options.router)?(this._routerRoot=this,this._router=this.$options.router,this._router.init(this),t.util.defineReactive(this,"_route",this._router.history.current)):this._routerRoot=this.$parent&&this.$parent._routerRoot||this,r(this,this)},destroyed:function(){r(this)}}),Object.defineProperty(t.prototype,"$router",{get:function(){return this._routerRoot._router}}),Object.defineProperty(t.prototype,"$route",{get:function(){return this._routerRoot._route}}),t.component("router-view",St),t.component("router-link",zt);var n=t.config.optionMergeStrategies;n.beforeRouteEnter=n.beforeRouteLeave=n.beforeRouteUpdate=n.created}}function g(t,e,r){var n=t.charAt(0);if("/"===n)return t;if("?"===n||"#"===n)return e+t;var o=e.split("/");r&&o[o.length-1]||o.pop();for(var i=t.replace(/^\//,"").split("/"),a=0;a<i.length;a++){var u=i[a];".."===u?o.pop():"."!==u&&o.push(u)}return""!==o[0]&&o.unshift(""),o.join("/")}function b(t){var e="",r="",n=t.indexOf("#");n>=0&&(e=t.slice(n),t=t.slice(0,n));var o=t.indexOf("?");return o>=0&&(r=t.slice(o+1),t=t.slice(0,o)),{path:t,query:r,hash:e}}function w(t){return t.replace(/\/\//g,"/")}function x(t,e){for(var r,n=[],o=0,i=0,a="",u=e&&e.delimiter||"/";null!=(r=Qt.exec(t));){var c=r[0],s=r[1],p=r.index;if(a+=t.slice(i,p),i=p+c.length,s)a+=s[1];else{var f=t[i],h=r[2],l=r[3],d=r[4],y=r[5],v=r[6],m=r[7];a&&(n.push(a),a="");var g=null!=h&&null!=f&&f!==h,b="+"===v||"*"===v,w="?"===v||"*"===v,x=r[2]||u,k=d||y;n.push({name:l||o++,prefix:h||"",delimiter:x,optional:w,repeat:b,partial:g,asterisk:!!m,pattern:k?C(k):m?".*":"[^"+O(x)+"]+?"})}}return i<t.length&&(a+=t.substr(i)),a&&n.push(a),n}function k(t){return encodeURI(t).replace(/[\/?#]/g,function(t){return"%"+t.charCodeAt(0).toString(16).toUpperCase()})}function R(t){return encodeURI(t).replace(/[?#]/g,function(t){return"%"+t.charCodeAt(0).toString(16).toUpperCase()})}function E(t){for(var e=new Array(t.length),r=0;r<t.length;r++)"object"==typeof t[r]&&(e[r]=new RegExp("^(?:"+t[r].pattern+")$"));return function(r,n){for(var o="",i=r||{},a=(n||{}).pretty?k:encodeURIComponent,u=0;u<t.length;u++){var c=t[u];if("string"!=typeof c){var s,p=i[c.name];if(null==p){if(c.optional){c.partial&&(o+=c.prefix);continue}throw new TypeError('Expected "'+c.name+'" to be defined')}if(Ft(p)){if(!c.repeat)throw new TypeError('Expected "'+c.name+'" to not repeat, but received `'+JSON.stringify(p)+"`");if(0===p.length){if(c.optional)continue;throw new TypeError('Expected "'+c.name+'" to not be empty')}for(var f=0;f<p.length;f++){if(s=a(p[f]),!e[u].test(s))throw new TypeError('Expected all "'+c.name+'" to match "'+c.pattern+'", but received `'+JSON.stringify(s)+"`");o+=(0===f?c.prefix:c.delimiter)+s}}else{if(s=c.asterisk?R(p):a(p),!e[u].test(s))throw new TypeError('Expected "'+c.name+'" to match "'+c.pattern+'", but received "'+s+'"');o+=c.prefix+s}}else o+=c}return o}}function O(t){return t.replace(/([.+*?=^!:${}()[\]|\/\\])/g,"\\$1")}function C(t){return t.replace(/([=!:$\/()])/g,"\\$1")}function j(t,e){return t.keys=e,t}function A(t){return t.sensitive?"":"i"}function _(t,e){var r=t.source.match(/\((?!\?)/g);if(r)for(var n=0;n<r.length;n++)e.push({name:n,prefix:null,delimiter:null,optional:!1,repeat:!1,partial:!1,asterisk:!1,pattern:null});return j(t,e)}function T(t,e,r){for(var n=[],o=0;o<t.length;o++)n.push(q(t[o],e,r).source);return j(new RegExp("(?:"+n.join("|")+")",A(r)),e)}function S(t,e,r){return $(x(t,r),e,r)}function $(t,e,r){Ft(e)||(r=e||r,e=[]);for(var n=(r=r||{}).strict,o=!1!==r.end,i="",a=0;a<t.length;a++){var u=t[a];if("string"==typeof u)i+=O(u);else{var c=O(u.prefix),s="(?:"+u.pattern+")";e.push(u),u.repeat&&(s+="(?:"+c+s+")*"),i+=s=u.optional?u.partial?c+"("+s+")?":"(?:"+c+"("+s+"))?":c+"("+s+")"}}var p=O(r.delimiter||"/"),f=i.slice(-p.length)===p;return n||(i=(f?i.slice(0,-p.length):i)+"(?:"+p+"(?=$))?"),i+=o?"$":n&&f?"":"(?="+p+"|$)",j(new RegExp("^"+i,A(r)),e)}function q(t,e,r){return Ft(e)||(r=e||r,e=[]),r=r||{},t instanceof RegExp?_(t,e):Ft(t)?T(t,e,r):S(t,e,r)}function L(t,e,r){try{return(Xt[t]||(Xt[t]=Dt.compile(t)))(e||{},{pretty:!0})}catch(t){return""}}function P(t,e,r,n){var o=e||[],i=r||Object.create(null),a=n||Object.create(null);t.forEach(function(t){U(o,i,a,t)});for(var u=0,c=o.length;u<c;u++)"*"===o[u]&&(o.push(o.splice(u,1)[0]),c--,u--);return{pathList:o,pathMap:i,nameMap:a}}function U(t,e,r,n,o,i){var a=n.path,u=n.name,c=n.pathToRegexpOptions||{},s=H(a,o,c.strict);"boolean"==typeof n.caseSensitive&&(c.sensitive=n.caseSensitive);var p={path:s,regex:M(s,c),components:n.components||{default:n.component},instances:{},name:u,parent:o,matchAs:i,redirect:n.redirect,beforeEnter:n.beforeEnter,meta:n.meta||{},props:null==n.props?{}:n.components?n.props:{default:n.props}};n.children&&n.children.forEach(function(n){var o=i?w(i+"/"+n.path):void 0;U(t,e,r,n,p,o)}),void 0!==n.alias&&(Array.isArray(n.alias)?n.alias:[n.alias]).forEach(function(i){var a={path:i,children:n.children};U(t,e,r,a,o,p.path||"/")}),e[p.path]||(t.push(p.path),e[p.path]=p),u&&(r[u]||(r[u]=p))}function M(t,e){return Dt(t,[],e)}function H(t,e,r){return r||(t=t.replace(/\/$/,"")),"/"===t[0]?t:null==e?t:w(e.path+"/"+t)}function I(t,e,r,n){var i="string"==typeof t?{path:t}:t;if(i.name||i._normalized)return i;if(!i.path&&i.params&&e){(i=V({},i))._normalized=!0;var a=V(V({},e.params),i.params);if(e.name)i.name=e.name,i.params=a;else if(e.matched.length){var u=e.matched[e.matched.length-1].path;i.path=L(u,a,"path "+e.path)}return i}var c=b(i.path||""),s=e&&e.path||"/",p=c.path?g(c.path,s,r||i.append):s,f=o(c.query,i.query,n&&n.options.parseQuery),h=i.hash||c.hash;return h&&"#"!==h.charAt(0)&&(h="#"+h),{_normalized:!0,path:p,query:f,hash:h}}function V(t,e){for(var r in e)t[r]=e[r];return t}function z(t,e){function r(t,r,n){var o=I(t,r,!1,e),a=o.name;if(a){var u=p[a];if(!u)return i(null,o);var f=u.regex.keys.filter(function(t){return!t.optional}).map(function(t){return t.name});if("object"!=typeof o.params&&(o.params={}),r&&"object"==typeof r.params)for(var h in r.params)!(h in o.params)&&f.indexOf(h)>-1&&(o.params[h]=r.params[h]);if(u)return o.path=L(u.path,o.params,'named route "'+a+'"'),i(u,o,n)}else if(o.path){o.params={};for(var l=0;l<c.length;l++){var d=c[l],y=s[d];if(B(y.regex,o.path,o.params))return i(y,o,n)}}return i(null,o)}function n(t,n){var o=t.redirect,a="function"==typeof o?o(u(t,n,null,e)):o;if("string"==typeof a&&(a={path:a}),!a||"object"!=typeof a)return i(null,n);var c=a,s=c.name,p=c.path,f=n.query,h=n.hash,l=n.params;if(f=c.hasOwnProperty("query")?c.query:f,h=c.hasOwnProperty("hash")?c.hash:h,l=c.hasOwnProperty("params")?c.params:l,s)return r({_normalized:!0,name:s,query:f,hash:h,params:l},void 0,n);if(p){var d=F(p,t);return r({_normalized:!0,path:L(d,l,'redirect route with path "'+d+'"'),query:f,hash:h},void 0,n)}return i(null,n)}function o(t,e,n){var o=r({_normalized:!0,path:L(n,e.params,'aliased route with path "'+n+'"')});if(o){var a=o.matched,u=a[a.length-1];return e.params=o.params,i(u,e)}return i(null,e)}function i(t,r,i){return t&&t.redirect?n(t,i||r):t&&t.matchAs?o(t,r,t.matchAs):u(t,r,i,e)}var a=P(t),c=a.pathList,s=a.pathMap,p=a.nameMap;return{match:r,addRoutes:function(t){P(t,c,s,p)}}}function B(t,e,r){var n=e.match(t);if(!n)return!1;if(!r)return!0;for(var o=1,i=n.length;o<i;++o){var a=t.keys[o-1],u="string"==typeof n[o]?decodeURIComponent(n[o]):n[o];a&&(r[a.name]=u)}return!0}function F(t,e){return g(t,e.parent?e.parent.path:"/",!0)}function D(){window.history.replaceState({key:et()},""),window.addEventListener("popstate",function(t){J(),t.state&&t.state.key&&rt(t.state.key)})}function K(t,e,r,n){if(t.app){var o=t.options.scrollBehavior;o&&t.app.$nextTick(function(){var t=N(),i=o(e,r,n?t:null);i&&("function"==typeof i.then?i.then(function(e){Z(e,t)}).catch(function(t){}):Z(i,t))})}}function J(){var t=et();t&&(Yt[t]={x:window.pageXOffset,y:window.pageYOffset})}function N(){var t=et();if(t)return Yt[t]}function Q(t,e){var r=document.documentElement.getBoundingClientRect(),n=t.getBoundingClientRect();return{x:n.left-r.left-e.x,y:n.top-r.top-e.y}}function X(t){return G(t.x)||G(t.y)}function Y(t){return{x:G(t.x)?t.x:window.pageXOffset,y:G(t.y)?t.y:window.pageYOffset}}function W(t){return{x:G(t.x)?t.x:0,y:G(t.y)?t.y:0}}function G(t){return"number"==typeof t}function Z(t,e){var r="object"==typeof t;if(r&&"string"==typeof t.selector){var n=document.querySelector(t.selector);if(n){var o=t.offset&&"object"==typeof t.offset?t.offset:{};e=Q(n,o=W(o))}else X(t)&&(e=Y(t))}else r&&X(t)&&(e=Y(t));e&&window.scrollTo(e.x,e.y)}function tt(){return Gt.now().toFixed(3)}function et(){return Zt}function rt(t){Zt=t}function nt(t,e){J();var r=window.history;try{e?r.replaceState({key:Zt},"",t):(Zt=tt(),r.pushState({key:Zt},"",t))}catch(r){window.location[e?"replace":"assign"](t)}}function ot(t){nt(t,!0)}function it(t,e,r){var n=function(o){o>=t.length?r():t[o]?e(t[o],function(){n(o+1)}):n(o+1)};n(0)}function at(t){return function(r,n,o){var i=!1,a=0,u=null;ut(t,function(t,r,n,c){if("function"==typeof t&&void 0===t.cid){i=!0,a++;var s,p=pt(function(e){st(e)&&(e=e.default),t.resolved="function"==typeof e?e:Tt.extend(e),n.components[c]=e,--a<=0&&o()}),f=pt(function(t){var r="Failed to resolve async component "+c+": "+t;u||(u=e(t)?t:new Error(r),o(u))});try{s=t(p,f)}catch(t){f(t)}if(s)if("function"==typeof s.then)s.then(p,f);else{var h=s.component;h&&"function"==typeof h.then&&h.then(p,f)}}}),i||o()}}function ut(t,e){return ct(t.map(function(t){return Object.keys(t.components).map(function(r){return e(t.components[r],t.instances[r],t,r)})}))}function ct(t){return Array.prototype.concat.apply([],t)}function st(t){return t.__esModule||te&&"Module"===t[Symbol.toStringTag]}function pt(t){var e=!1;return function(){for(var r=[],n=arguments.length;n--;)r[n]=arguments[n];if(!e)return e=!0,t.apply(this,r)}}function ft(t){if(!t)if(Bt){var e=document.querySelector("base");t=(t=e&&e.getAttribute("href")||"/").replace(/^https?:\/\/[^\/]+/,"")}else t="/";return"/"!==t.charAt(0)&&(t="/"+t),t.replace(/\/$/,"")}function ht(t,e){var r,n=Math.max(t.length,e.length);for(r=0;r<n&&t[r]===e[r];r++);return{updated:e.slice(0,r),activated:e.slice(r),deactivated:t.slice(r)}}function lt(t,e,r,n){var o=ut(t,function(t,n,o,i){var a=dt(t,e);if(a)return Array.isArray(a)?a.map(function(t){return r(t,n,o,i)}):r(a,n,o,i)});return ct(n?o.reverse():o)}function dt(t,e){return"function"!=typeof t&&(t=Tt.extend(t)),t.options[e]}function yt(t){return lt(t,"beforeRouteLeave",mt,!0)}function vt(t){return lt(t,"beforeRouteUpdate",mt)}function mt(t,e){if(e)return function(){return t.apply(e,arguments)}}function gt(t,e,r){return lt(t,"beforeRouteEnter",function(t,n,o,i){return bt(t,o,i,e,r)})}function bt(t,e,r,n,o){return function(i,a,u){return t(i,a,function(t){u(t),"function"==typeof t&&n.push(function(){wt(t,e.instances,r,o)})})}}function wt(t,e,r,n){e[r]?t(e[r]):n()&&setTimeout(function(){wt(t,e,r,n)},16)}function xt(t){var e=window.location.pathname;return t&&0===e.indexOf(t)&&(e=e.slice(t.length)),(e||"/")+window.location.search+window.location.hash}function kt(t){var e=xt(t);if(!/^\/#/.test(e))return window.location.replace(w(t+"/#"+e)),!0}function Rt(){var t=Et();return"/"===t.charAt(0)||(jt("/"+t),!1)}function Et(){var t=window.location.href,e=t.indexOf("#");return-1===e?"":t.slice(e+1)}function Ot(t){var e=window.location.href,r=e.indexOf("#");return(r>=0?e.slice(0,r):e)+"#"+t}function Ct(t){Wt?nt(Ot(t)):window.location.hash=t}function jt(t){Wt?ot(Ot(t)):window.location.replace(Ot(t))}function At(t,e){return t.push(e),function(){var r=t.indexOf(e);r>-1&&t.splice(r,1)}}function _t(t,e,r){var n="hash"===r?"#"+e:e;return t?w(t+"/"+n):n}var Tt,St={name:"router-view",functional:!0,props:{name:{type:String,default:"default"}},render:function(t,e){var o=e.props,i=e.children,a=e.parent,u=e.data;u.routerView=!0;for(var c=a.$createElement,s=o.name,p=a.$route,f=a._routerViewCache||(a._routerViewCache={}),h=0,l=!1;a&&a._routerRoot!==a;)a.$vnode&&a.$vnode.data.routerView&&h++,a._inactive&&(l=!0),a=a.$parent;if(u.routerViewDepth=h,l)return c(f[s],u,i);var d=p.matched[h];if(!d)return f[s]=null,c();var y=f[s]=d.components[s];u.registerRouteInstance=function(t,e){var r=d.instances[s];(e&&r!==t||!e&&r===t)&&(d.instances[s]=e)},(u.hook||(u.hook={})).prepatch=function(t,e){d.instances[s]=e.componentInstance};var v=u.props=r(p,d.props&&d.props[s]);if(v){v=u.props=n({},v);var m=u.attrs=u.attrs||{};for(var g in v)y.props&&g in y.props||(m[g]=v[g],delete v[g])}return c(y,u,i)}},$t=/[!'()*]/g,qt=function(t){return"%"+t.charCodeAt(0).toString(16)},Lt=/%2C/g,Pt=function(t){return encodeURIComponent(t).replace($t,qt).replace(Lt,",")},Ut=decodeURIComponent,Mt=/\/?$/,Ht=u(null,{path:"/"}),It=[String,Object],Vt=[String,Array],zt={name:"router-link",props:{to:{type:It,required:!0},tag:{type:String,default:"a"},exact:Boolean,append:Boolean,replace:Boolean,activeClass:String,exactActiveClass:String,event:{type:Vt,default:"click"}},render:function(t){var e=this,r=this.$router,n=this.$route,o=r.resolve(this.to,n,this.append),i=o.location,a=o.route,c=o.href,s={},p=r.options.linkActiveClass,h=r.options.linkExactActiveClass,d=null==p?"router-link-active":p,m=null==h?"router-link-exact-active":h,g=null==this.activeClass?d:this.activeClass,b=null==this.exactActiveClass?m:this.exactActiveClass,w=i.path?u(null,i,null,r):a;s[b]=f(n,w),s[g]=this.exact?s[b]:l(n,w);var x=function(t){y(t)&&(e.replace?r.replace(i):r.push(i))},k={click:y};Array.isArray(this.event)?this.event.forEach(function(t){k[t]=x}):k[this.event]=x;var R={class:s};if("a"===this.tag)R.on=k,R.attrs={href:c};else{var E=v(this.$slots.default);if(E){E.isStatic=!1;var O=Tt.util.extend;(E.data=O({},E.data)).on=k,(E.data.attrs=O({},E.data.attrs)).href=c}else R.on=k}return t(this.tag,R,this.$slots.default)}},Bt="undefined"!=typeof window,Ft=Array.isArray||function(t){return"[object Array]"==Object.prototype.toString.call(t)},Dt=q,Kt=x,Jt=E,Nt=$,Qt=new RegExp(["(\\\\.)","([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))"].join("|"),"g");Dt.parse=Kt,Dt.compile=function(t,e){return E(x(t,e))},Dt.tokensToFunction=Jt,Dt.tokensToRegExp=Nt;var Xt=Object.create(null),Yt=Object.create(null),Wt=Bt&&function(){var t=window.navigator.userAgent;return(-1===t.indexOf("Android 2.")&&-1===t.indexOf("Android 4.0")||-1===t.indexOf("Mobile Safari")||-1!==t.indexOf("Chrome")||-1!==t.indexOf("Windows Phone"))&&(window.history&&"pushState"in window.history)}(),Gt=Bt&&window.performance&&window.performance.now?window.performance:Date,Zt=tt(),te="function"==typeof Symbol&&"symbol"==typeof Symbol.toStringTag,ee=function(t,e){this.router=t,this.base=ft(e),this.current=Ht,this.pending=null,this.ready=!1,this.readyCbs=[],this.readyErrorCbs=[],this.errorCbs=[]};ee.prototype.listen=function(t){this.cb=t},ee.prototype.onReady=function(t,e){this.ready?t():(this.readyCbs.push(t),e&&this.readyErrorCbs.push(e))},ee.prototype.onError=function(t){this.errorCbs.push(t)},ee.prototype.transitionTo=function(t,e,r){var n=this,o=this.router.match(t,this.current);this.confirmTransition(o,function(){n.updateRoute(o),e&&e(o),n.ensureURL(),n.ready||(n.ready=!0,n.readyCbs.forEach(function(t){t(o)}))},function(t){r&&r(t),t&&!n.ready&&(n.ready=!0,n.readyErrorCbs.forEach(function(e){e(t)}))})},ee.prototype.confirmTransition=function(r,n,o){var i=this,a=this.current,u=function(r){e(r)&&(i.errorCbs.length?i.errorCbs.forEach(function(t){t(r)}):(t(!1,"uncaught error during route navigation:"),console.error(r))),o&&o(r)};if(f(r,a)&&r.matched.length===a.matched.length)return this.ensureURL(),u();var c=ht(this.current.matched,r.matched),s=c.updated,p=c.deactivated,h=c.activated,l=[].concat(yt(p),this.router.beforeHooks,vt(s),h.map(function(t){return t.beforeEnter}),at(h));this.pending=r;var d=function(t,n){if(i.pending!==r)return u();try{t(r,a,function(t){!1===t||e(t)?(i.ensureURL(!0),u(t)):"string"==typeof t||"object"==typeof t&&("string"==typeof t.path||"string"==typeof t.name)?(u(),"object"==typeof t&&t.replace?i.replace(t):i.push(t)):n(t)})}catch(t){u(t)}};it(l,d,function(){var t=[];it(gt(h,t,function(){return i.current===r}).concat(i.router.resolveHooks),d,function(){if(i.pending!==r)return u();i.pending=null,n(r),i.router.app&&i.router.app.$nextTick(function(){t.forEach(function(t){t()})})})})},ee.prototype.updateRoute=function(t){var e=this.current;this.current=t,this.cb&&this.cb(t),this.router.afterHooks.forEach(function(r){r&&r(t,e)})};var re=function(t){function e(e,r){var n=this;t.call(this,e,r);var o=e.options.scrollBehavior;o&&D();var i=xt(this.base);window.addEventListener("popstate",function(t){var r=n.current,a=xt(n.base);n.current===Ht&&a===i||n.transitionTo(a,function(t){o&&K(e,t,r,!0)})})}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.go=function(t){window.history.go(t)},e.prototype.push=function(t,e,r){var n=this,o=this.current;this.transitionTo(t,function(t){nt(w(n.base+t.fullPath)),K(n.router,t,o,!1),e&&e(t)},r)},e.prototype.replace=function(t,e,r){var n=this,o=this.current;this.transitionTo(t,function(t){ot(w(n.base+t.fullPath)),K(n.router,t,o,!1),e&&e(t)},r)},e.prototype.ensureURL=function(t){if(xt(this.base)!==this.current.fullPath){var e=w(this.base+this.current.fullPath);t?nt(e):ot(e)}},e.prototype.getCurrentLocation=function(){return xt(this.base)},e}(ee),ne=function(t){function e(e,r,n){t.call(this,e,r),n&&kt(this.base)||Rt()}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.setupListeners=function(){var t=this,e=this.router.options.scrollBehavior,r=Wt&&e;r&&D(),window.addEventListener(Wt?"popstate":"hashchange",function(){var e=t.current;Rt()&&t.transitionTo(Et(),function(n){r&&K(t.router,n,e,!0),Wt||jt(n.fullPath)})})},e.prototype.push=function(t,e,r){var n=this,o=this.current;this.transitionTo(t,function(t){Ct(t.fullPath),K(n.router,t,o,!1),e&&e(t)},r)},e.prototype.replace=function(t,e,r){var n=this,o=this.current;this.transitionTo(t,function(t){jt(t.fullPath),K(n.router,t,o,!1),e&&e(t)},r)},e.prototype.go=function(t){window.history.go(t)},e.prototype.ensureURL=function(t){var e=this.current.fullPath;Et()!==e&&(t?Ct(e):jt(e))},e.prototype.getCurrentLocation=function(){return Et()},e}(ee),oe=function(t){function e(e,r){t.call(this,e,r),this.stack=[],this.index=-1}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.push=function(t,e,r){var n=this;this.transitionTo(t,function(t){n.stack=n.stack.slice(0,n.index+1).concat(t),n.index++,e&&e(t)},r)},e.prototype.replace=function(t,e,r){var n=this;this.transitionTo(t,function(t){n.stack=n.stack.slice(0,n.index).concat(t),e&&e(t)},r)},e.prototype.go=function(t){var e=this,r=this.index+t;if(!(r<0||r>=this.stack.length)){var n=this.stack[r];this.confirmTransition(n,function(){e.index=r,e.updateRoute(n)})}},e.prototype.getCurrentLocation=function(){var t=this.stack[this.stack.length-1];return t?t.fullPath:"/"},e.prototype.ensureURL=function(){},e}(ee),ie=function(t){void 0===t&&(t={}),this.app=null,this.apps=[],this.options=t,this.beforeHooks=[],this.resolveHooks=[],this.afterHooks=[],this.matcher=z(t.routes||[],this);var e=t.mode||"hash";switch(this.fallback="history"===e&&!Wt&&!1!==t.fallback,this.fallback&&(e="hash"),Bt||(e="abstract"),this.mode=e,e){case"history":this.history=new re(this,t.base);break;case"hash":this.history=new ne(this,t.base,this.fallback);break;case"abstract":this.history=new oe(this,t.base)}},ae={currentRoute:{configurable:!0}};return ie.prototype.match=function(t,e,r){return this.matcher.match(t,e,r)},ae.currentRoute.get=function(){return this.history&&this.history.current},ie.prototype.init=function(t){var e=this;if(this.apps.push(t),!this.app){this.app=t;var r=this.history;if(r instanceof re)r.transitionTo(r.getCurrentLocation());else if(r instanceof ne){var n=function(){r.setupListeners()};r.transitionTo(r.getCurrentLocation(),n,n)}r.listen(function(t){e.apps.forEach(function(e){e._route=t})})}},ie.prototype.beforeEach=function(t){return At(this.beforeHooks,t)},ie.prototype.beforeResolve=function(t){return At(this.resolveHooks,t)},ie.prototype.afterEach=function(t){return At(this.afterHooks,t)},ie.prototype.onReady=function(t,e){this.history.onReady(t,e)},ie.prototype.onError=function(t){this.history.onError(t)},ie.prototype.push=function(t,e,r){this.history.push(t,e,r)},ie.prototype.replace=function(t,e,r){this.history.replace(t,e,r)},ie.prototype.go=function(t){this.history.go(t)},ie.prototype.back=function(){this.go(-1)},ie.prototype.forward=function(){this.go(1)},ie.prototype.getMatchedComponents=function(t){var e=t?t.matched?t:this.resolve(t).route:this.currentRoute;return e?[].concat.apply([],e.matched.map(function(t){return Object.keys(t.components).map(function(e){return t.components[e]})})):[]},ie.prototype.resolve=function(t,e,r){var n=I(t,e||this.history.current,r,this),o=this.match(n,e),i=o.redirectedFrom||o.fullPath;return{location:n,route:o,href:_t(this.history.base,i,this.mode),normalizedTo:n,resolved:o}},ie.prototype.addRoutes=function(t){this.matcher.addRoutes(t),this.history.current!==Ht&&this.history.transitionTo(this.history.getCurrentLocation())},Object.defineProperties(ie.prototype,ae),ie.install=m,ie.version="3.0.1",Bt&&window.Vue&&window.Vue.use(ie),ie});


--------------------------------------------------------------------------------
/vendor/assets/javascripts/dist/vuex.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * vuex v3.0.1
  3 |  * (c) 2017 Evan You
  4 |  * @license MIT
  5 |  */
  6 | (function (global, factory) {
  7 | 	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  8 | 	typeof define === 'function' && define.amd ? define(factory) :
  9 | 	(global.Vuex = factory());
 10 | }(this, (function () { 'use strict';
 11 | 
 12 | var applyMixin = function (Vue) {
 13 |   var version = Number(Vue.version.split('.')[0]);
 14 | 
 15 |   if (version >= 2) {
 16 |     Vue.mixin({ beforeCreate: vuexInit });
 17 |   } else {
 18 |     // override init and inject vuex init procedure
 19 |     // for 1.x backwards compatibility.
 20 |     var _init = Vue.prototype._init;
 21 |     Vue.prototype._init = function (options) {
 22 |       if ( options === void 0 ) options = {};
 23 | 
 24 |       options.init = options.init
 25 |         ? [vuexInit].concat(options.init)
 26 |         : vuexInit;
 27 |       _init.call(this, options);
 28 |     };
 29 |   }
 30 | 
 31 |   /**
 32 |    * Vuex init hook, injected into each instances init hooks list.
 33 |    */
 34 | 
 35 |   function vuexInit () {
 36 |     var options = this.$options;
 37 |     // store injection
 38 |     if (options.store) {
 39 |       this.$store = typeof options.store === 'function'
 40 |         ? options.store()
 41 |         : options.store;
 42 |     } else if (options.parent && options.parent.$store) {
 43 |       this.$store = options.parent.$store;
 44 |     }
 45 |   }
 46 | };
 47 | 
 48 | var devtoolHook =
 49 |   typeof window !== 'undefined' &&
 50 |   window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
 51 | 
 52 | function devtoolPlugin (store) {
 53 |   if (!devtoolHook) { return }
 54 | 
 55 |   store._devtoolHook = devtoolHook;
 56 | 
 57 |   devtoolHook.emit('vuex:init', store);
 58 | 
 59 |   devtoolHook.on('vuex:travel-to-state', function (targetState) {
 60 |     store.replaceState(targetState);
 61 |   });
 62 | 
 63 |   store.subscribe(function (mutation, state) {
 64 |     devtoolHook.emit('vuex:mutation', mutation, state);
 65 |   });
 66 | }
 67 | 
 68 | /**
 69 |  * Get the first item that pass the test
 70 |  * by second argument function
 71 |  *
 72 |  * @param {Array} list
 73 |  * @param {Function} f
 74 |  * @return {*}
 75 |  */
 76 | /**
 77 |  * Deep copy the given object considering circular structure.
 78 |  * This function caches all nested objects and its copies.
 79 |  * If it detects circular structure, use cached copy to avoid infinite loop.
 80 |  *
 81 |  * @param {*} obj
 82 |  * @param {Array<Object>} cache
 83 |  * @return {*}
 84 |  */
 85 | 
 86 | 
 87 | /**
 88 |  * forEach for object
 89 |  */
 90 | function forEachValue (obj, fn) {
 91 |   Object.keys(obj).forEach(function (key) { return fn(obj[key], key); });
 92 | }
 93 | 
 94 | function isObject (obj) {
 95 |   return obj !== null && typeof obj === 'object'
 96 | }
 97 | 
 98 | function isPromise (val) {
 99 |   return val && typeof val.then === 'function'
100 | }
101 | 
102 | function assert (condition, msg) {
103 |   if (!condition) { throw new Error(("[vuex] " + msg)) }
104 | }
105 | 
106 | var Module = function Module (rawModule, runtime) {
107 |   this.runtime = runtime;
108 |   this._children = Object.create(null);
109 |   this._rawModule = rawModule;
110 |   var rawState = rawModule.state;
111 |   this.state = (typeof rawState === 'function' ? rawState() : rawState) || {};
112 | };
113 | 
114 | var prototypeAccessors$1 = { namespaced: { configurable: true } };
115 | 
116 | prototypeAccessors$1.namespaced.get = function () {
117 |   return !!this._rawModule.namespaced
118 | };
119 | 
120 | Module.prototype.addChild = function addChild (key, module) {
121 |   this._children[key] = module;
122 | };
123 | 
124 | Module.prototype.removeChild = function removeChild (key) {
125 |   delete this._children[key];
126 | };
127 | 
128 | Module.prototype.getChild = function getChild (key) {
129 |   return this._children[key]
130 | };
131 | 
132 | Module.prototype.update = function update (rawModule) {
133 |   this._rawModule.namespaced = rawModule.namespaced;
134 |   if (rawModule.actions) {
135 |     this._rawModule.actions = rawModule.actions;
136 |   }
137 |   if (rawModule.mutations) {
138 |     this._rawModule.mutations = rawModule.mutations;
139 |   }
140 |   if (rawModule.getters) {
141 |     this._rawModule.getters = rawModule.getters;
142 |   }
143 | };
144 | 
145 | Module.prototype.forEachChild = function forEachChild (fn) {
146 |   forEachValue(this._children, fn);
147 | };
148 | 
149 | Module.prototype.forEachGetter = function forEachGetter (fn) {
150 |   if (this._rawModule.getters) {
151 |     forEachValue(this._rawModule.getters, fn);
152 |   }
153 | };
154 | 
155 | Module.prototype.forEachAction = function forEachAction (fn) {
156 |   if (this._rawModule.actions) {
157 |     forEachValue(this._rawModule.actions, fn);
158 |   }
159 | };
160 | 
161 | Module.prototype.forEachMutation = function forEachMutation (fn) {
162 |   if (this._rawModule.mutations) {
163 |     forEachValue(this._rawModule.mutations, fn);
164 |   }
165 | };
166 | 
167 | Object.defineProperties( Module.prototype, prototypeAccessors$1 );
168 | 
169 | var ModuleCollection = function ModuleCollection (rawRootModule) {
170 |   // register root module (Vuex.Store options)
171 |   this.register([], rawRootModule, false);
172 | };
173 | 
174 | ModuleCollection.prototype.get = function get (path) {
175 |   return path.reduce(function (module, key) {
176 |     return module.getChild(key)
177 |   }, this.root)
178 | };
179 | 
180 | ModuleCollection.prototype.getNamespace = function getNamespace (path) {
181 |   var module = this.root;
182 |   return path.reduce(function (namespace, key) {
183 |     module = module.getChild(key);
184 |     return namespace + (module.namespaced ? key + '/' : '')
185 |   }, '')
186 | };
187 | 
188 | ModuleCollection.prototype.update = function update$1 (rawRootModule) {
189 |   update([], this.root, rawRootModule);
190 | };
191 | 
192 | ModuleCollection.prototype.register = function register (path, rawModule, runtime) {
193 |     var this$1 = this;
194 |     if ( runtime === void 0 ) runtime = true;
195 | 
196 |   {
197 |     assertRawModule(path, rawModule);
198 |   }
199 | 
200 |   var newModule = new Module(rawModule, runtime);
201 |   if (path.length === 0) {
202 |     this.root = newModule;
203 |   } else {
204 |     var parent = this.get(path.slice(0, -1));
205 |     parent.addChild(path[path.length - 1], newModule);
206 |   }
207 | 
208 |   // register nested modules
209 |   if (rawModule.modules) {
210 |     forEachValue(rawModule.modules, function (rawChildModule, key) {
211 |       this$1.register(path.concat(key), rawChildModule, runtime);
212 |     });
213 |   }
214 | };
215 | 
216 | ModuleCollection.prototype.unregister = function unregister (path) {
217 |   var parent = this.get(path.slice(0, -1));
218 |   var key = path[path.length - 1];
219 |   if (!parent.getChild(key).runtime) { return }
220 | 
221 |   parent.removeChild(key);
222 | };
223 | 
224 | function update (path, targetModule, newModule) {
225 |   {
226 |     assertRawModule(path, newModule);
227 |   }
228 | 
229 |   // update target module
230 |   targetModule.update(newModule);
231 | 
232 |   // update nested modules
233 |   if (newModule.modules) {
234 |     for (var key in newModule.modules) {
235 |       if (!targetModule.getChild(key)) {
236 |         {
237 |           console.warn(
238 |             "[vuex] trying to add a new module '" + key + "' on hot reloading, " +
239 |             'manual reload is needed'
240 |           );
241 |         }
242 |         return
243 |       }
244 |       update(
245 |         path.concat(key),
246 |         targetModule.getChild(key),
247 |         newModule.modules[key]
248 |       );
249 |     }
250 |   }
251 | }
252 | 
253 | var functionAssert = {
254 |   assert: function (value) { return typeof value === 'function'; },
255 |   expected: 'function'
256 | };
257 | 
258 | var objectAssert = {
259 |   assert: function (value) { return typeof value === 'function' ||
260 |     (typeof value === 'object' && typeof value.handler === 'function'); },
261 |   expected: 'function or object with "handler" function'
262 | };
263 | 
264 | var assertTypes = {
265 |   getters: functionAssert,
266 |   mutations: functionAssert,
267 |   actions: objectAssert
268 | };
269 | 
270 | function assertRawModule (path, rawModule) {
271 |   Object.keys(assertTypes).forEach(function (key) {
272 |     if (!rawModule[key]) { return }
273 | 
274 |     var assertOptions = assertTypes[key];
275 | 
276 |     forEachValue(rawModule[key], function (value, type) {
277 |       assert(
278 |         assertOptions.assert(value),
279 |         makeAssertionMessage(path, key, type, value, assertOptions.expected)
280 |       );
281 |     });
282 |   });
283 | }
284 | 
285 | function makeAssertionMessage (path, key, type, value, expected) {
286 |   var buf = key + " should be " + expected + " but \"" + key + "." + type + "\"";
287 |   if (path.length > 0) {
288 |     buf += " in module \"" + (path.join('.')) + "\"";
289 |   }
290 |   buf += " is " + (JSON.stringify(value)) + ".";
291 |   return buf
292 | }
293 | 
294 | var Vue; // bind on install
295 | 
296 | var Store = function Store (options) {
297 |   var this$1 = this;
298 |   if ( options === void 0 ) options = {};
299 | 
300 |   // Auto install if it is not done yet and `window` has `Vue`.
301 |   // To allow users to avoid auto-installation in some cases,
302 |   // this code should be placed here. See #731
303 |   if (!Vue && typeof window !== 'undefined' && window.Vue) {
304 |     install(window.Vue);
305 |   }
306 | 
307 |   {
308 |     assert(Vue, "must call Vue.use(Vuex) before creating a store instance.");
309 |     assert(typeof Promise !== 'undefined', "vuex requires a Promise polyfill in this browser.");
310 |     assert(this instanceof Store, "Store must be called with the new operator.");
311 |   }
312 | 
313 |   var plugins = options.plugins; if ( plugins === void 0 ) plugins = [];
314 |   var strict = options.strict; if ( strict === void 0 ) strict = false;
315 | 
316 |   var state = options.state; if ( state === void 0 ) state = {};
317 |   if (typeof state === 'function') {
318 |     state = state() || {};
319 |   }
320 | 
321 |   // store internal state
322 |   this._committing = false;
323 |   this._actions = Object.create(null);
324 |   this._actionSubscribers = [];
325 |   this._mutations = Object.create(null);
326 |   this._wrappedGetters = Object.create(null);
327 |   this._modules = new ModuleCollection(options);
328 |   this._modulesNamespaceMap = Object.create(null);
329 |   this._subscribers = [];
330 |   this._watcherVM = new Vue();
331 | 
332 |   // bind commit and dispatch to self
333 |   var store = this;
334 |   var ref = this;
335 |   var dispatch = ref.dispatch;
336 |   var commit = ref.commit;
337 |   this.dispatch = function boundDispatch (type, payload) {
338 |     return dispatch.call(store, type, payload)
339 |   };
340 |   this.commit = function boundCommit (type, payload, options) {
341 |     return commit.call(store, type, payload, options)
342 |   };
343 | 
344 |   // strict mode
345 |   this.strict = strict;
346 | 
347 |   // init root module.
348 |   // this also recursively registers all sub-modules
349 |   // and collects all module getters inside this._wrappedGetters
350 |   installModule(this, state, [], this._modules.root);
351 | 
352 |   // initialize the store vm, which is responsible for the reactivity
353 |   // (also registers _wrappedGetters as computed properties)
354 |   resetStoreVM(this, state);
355 | 
356 |   // apply plugins
357 |   plugins.forEach(function (plugin) { return plugin(this$1); });
358 | 
359 |   if (Vue.config.devtools) {
360 |     devtoolPlugin(this);
361 |   }
362 | };
363 | 
364 | var prototypeAccessors = { state: { configurable: true } };
365 | 
366 | prototypeAccessors.state.get = function () {
367 |   return this._vm._data.$$state
368 | };
369 | 
370 | prototypeAccessors.state.set = function (v) {
371 |   {
372 |     assert(false, "Use store.replaceState() to explicit replace store state.");
373 |   }
374 | };
375 | 
376 | Store.prototype.commit = function commit (_type, _payload, _options) {
377 |     var this$1 = this;
378 | 
379 |   // check object-style commit
380 |   var ref = unifyObjectStyle(_type, _payload, _options);
381 |     var type = ref.type;
382 |     var payload = ref.payload;
383 |     var options = ref.options;
384 | 
385 |   var mutation = { type: type, payload: payload };
386 |   var entry = this._mutations[type];
387 |   if (!entry) {
388 |     {
389 |       console.error(("[vuex] unknown mutation type: " + type));
390 |     }
391 |     return
392 |   }
393 |   this._withCommit(function () {
394 |     entry.forEach(function commitIterator (handler) {
395 |       handler(payload);
396 |     });
397 |   });
398 |   this._subscribers.forEach(function (sub) { return sub(mutation, this$1.state); });
399 | 
400 |   if (
401 |     "development" !== 'production' &&
402 |     options && options.silent
403 |   ) {
404 |     console.warn(
405 |       "[vuex] mutation type: " + type + ". Silent option has been removed. " +
406 |       'Use the filter functionality in the vue-devtools'
407 |     );
408 |   }
409 | };
410 | 
411 | Store.prototype.dispatch = function dispatch (_type, _payload) {
412 |     var this$1 = this;
413 | 
414 |   // check object-style dispatch
415 |   var ref = unifyObjectStyle(_type, _payload);
416 |     var type = ref.type;
417 |     var payload = ref.payload;
418 | 
419 |   var action = { type: type, payload: payload };
420 |   var entry = this._actions[type];
421 |   if (!entry) {
422 |     {
423 |       console.error(("[vuex] unknown action type: " + type));
424 |     }
425 |     return
426 |   }
427 | 
428 |   this._actionSubscribers.forEach(function (sub) { return sub(action, this$1.state); });
429 | 
430 |   return entry.length > 1
431 |     ? Promise.all(entry.map(function (handler) { return handler(payload); }))
432 |     : entry[0](payload)
433 | };
434 | 
435 | Store.prototype.subscribe = function subscribe (fn) {
436 |   return genericSubscribe(fn, this._subscribers)
437 | };
438 | 
439 | Store.prototype.subscribeAction = function subscribeAction (fn) {
440 |   return genericSubscribe(fn, this._actionSubscribers)
441 | };
442 | 
443 | Store.prototype.watch = function watch (getter, cb, options) {
444 |     var this$1 = this;
445 | 
446 |   {
447 |     assert(typeof getter === 'function', "store.watch only accepts a function.");
448 |   }
449 |   return this._watcherVM.$watch(function () { return getter(this$1.state, this$1.getters); }, cb, options)
450 | };
451 | 
452 | Store.prototype.replaceState = function replaceState (state) {
453 |     var this$1 = this;
454 | 
455 |   this._withCommit(function () {
456 |     this$1._vm._data.$$state = state;
457 |   });
458 | };
459 | 
460 | Store.prototype.registerModule = function registerModule (path, rawModule, options) {
461 |     if ( options === void 0 ) options = {};
462 | 
463 |   if (typeof path === 'string') { path = [path]; }
464 | 
465 |   {
466 |     assert(Array.isArray(path), "module path must be a string or an Array.");
467 |     assert(path.length > 0, 'cannot register the root module by using registerModule.');
468 |   }
469 | 
470 |   this._modules.register(path, rawModule);
471 |   installModule(this, this.state, path, this._modules.get(path), options.preserveState);
472 |   // reset store to update getters...
473 |   resetStoreVM(this, this.state);
474 | };
475 | 
476 | Store.prototype.unregisterModule = function unregisterModule (path) {
477 |     var this$1 = this;
478 | 
479 |   if (typeof path === 'string') { path = [path]; }
480 | 
481 |   {
482 |     assert(Array.isArray(path), "module path must be a string or an Array.");
483 |   }
484 | 
485 |   this._modules.unregister(path);
486 |   this._withCommit(function () {
487 |     var parentState = getNestedState(this$1.state, path.slice(0, -1));
488 |     Vue.delete(parentState, path[path.length - 1]);
489 |   });
490 |   resetStore(this);
491 | };
492 | 
493 | Store.prototype.hotUpdate = function hotUpdate (newOptions) {
494 |   this._modules.update(newOptions);
495 |   resetStore(this, true);
496 | };
497 | 
498 | Store.prototype._withCommit = function _withCommit (fn) {
499 |   var committing = this._committing;
500 |   this._committing = true;
501 |   fn();
502 |   this._committing = committing;
503 | };
504 | 
505 | Object.defineProperties( Store.prototype, prototypeAccessors );
506 | 
507 | function genericSubscribe (fn, subs) {
508 |   if (subs.indexOf(fn) < 0) {
509 |     subs.push(fn);
510 |   }
511 |   return function () {
512 |     var i = subs.indexOf(fn);
513 |     if (i > -1) {
514 |       subs.splice(i, 1);
515 |     }
516 |   }
517 | }
518 | 
519 | function resetStore (store, hot) {
520 |   store._actions = Object.create(null);
521 |   store._mutations = Object.create(null);
522 |   store._wrappedGetters = Object.create(null);
523 |   store._modulesNamespaceMap = Object.create(null);
524 |   var state = store.state;
525 |   // init all modules
526 |   installModule(store, state, [], store._modules.root, true);
527 |   // reset vm
528 |   resetStoreVM(store, state, hot);
529 | }
530 | 
531 | function resetStoreVM (store, state, hot) {
532 |   var oldVm = store._vm;
533 | 
534 |   // bind store public getters
535 |   store.getters = {};
536 |   var wrappedGetters = store._wrappedGetters;
537 |   var computed = {};
538 |   forEachValue(wrappedGetters, function (fn, key) {
539 |     // use computed to leverage its lazy-caching mechanism
540 |     computed[key] = function () { return fn(store); };
541 |     Object.defineProperty(store.getters, key, {
542 |       get: function () { return store._vm[key]; },
543 |       enumerable: true // for local getters
544 |     });
545 |   });
546 | 
547 |   // use a Vue instance to store the state tree
548 |   // suppress warnings just in case the user has added
549 |   // some funky global mixins
550 |   var silent = Vue.config.silent;
551 |   Vue.config.silent = true;
552 |   store._vm = new Vue({
553 |     data: {
554 |       $$state: state
555 |     },
556 |     computed: computed
557 |   });
558 |   Vue.config.silent = silent;
559 | 
560 |   // enable strict mode for new vm
561 |   if (store.strict) {
562 |     enableStrictMode(store);
563 |   }
564 | 
565 |   if (oldVm) {
566 |     if (hot) {
567 |       // dispatch changes in all subscribed watchers
568 |       // to force getter re-evaluation for hot reloading.
569 |       store._withCommit(function () {
570 |         oldVm._data.$$state = null;
571 |       });
572 |     }
573 |     Vue.nextTick(function () { return oldVm.$destroy(); });
574 |   }
575 | }
576 | 
577 | function installModule (store, rootState, path, module, hot) {
578 |   var isRoot = !path.length;
579 |   var namespace = store._modules.getNamespace(path);
580 | 
581 |   // register in namespace map
582 |   if (module.namespaced) {
583 |     store._modulesNamespaceMap[namespace] = module;
584 |   }
585 | 
586 |   // set state
587 |   if (!isRoot && !hot) {
588 |     var parentState = getNestedState(rootState, path.slice(0, -1));
589 |     var moduleName = path[path.length - 1];
590 |     store._withCommit(function () {
591 |       Vue.set(parentState, moduleName, module.state);
592 |     });
593 |   }
594 | 
595 |   var local = module.context = makeLocalContext(store, namespace, path);
596 | 
597 |   module.forEachMutation(function (mutation, key) {
598 |     var namespacedType = namespace + key;
599 |     registerMutation(store, namespacedType, mutation, local);
600 |   });
601 | 
602 |   module.forEachAction(function (action, key) {
603 |     var type = action.root ? key : namespace + key;
604 |     var handler = action.handler || action;
605 |     registerAction(store, type, handler, local);
606 |   });
607 | 
608 |   module.forEachGetter(function (getter, key) {
609 |     var namespacedType = namespace + key;
610 |     registerGetter(store, namespacedType, getter, local);
611 |   });
612 | 
613 |   module.forEachChild(function (child, key) {
614 |     installModule(store, rootState, path.concat(key), child, hot);
615 |   });
616 | }
617 | 
618 | /**
619 |  * make localized dispatch, commit, getters and state
620 |  * if there is no namespace, just use root ones
621 |  */
622 | function makeLocalContext (store, namespace, path) {
623 |   var noNamespace = namespace === '';
624 | 
625 |   var local = {
626 |     dispatch: noNamespace ? store.dispatch : function (_type, _payload, _options) {
627 |       var args = unifyObjectStyle(_type, _payload, _options);
628 |       var payload = args.payload;
629 |       var options = args.options;
630 |       var type = args.type;
631 | 
632 |       if (!options || !options.root) {
633 |         type = namespace + type;
634 |         if ("development" !== 'production' && !store._actions[type]) {
635 |           console.error(("[vuex] unknown local action type: " + (args.type) + ", global type: " + type));
636 |           return
637 |         }
638 |       }
639 | 
640 |       return store.dispatch(type, payload)
641 |     },
642 | 
643 |     commit: noNamespace ? store.commit : function (_type, _payload, _options) {
644 |       var args = unifyObjectStyle(_type, _payload, _options);
645 |       var payload = args.payload;
646 |       var options = args.options;
647 |       var type = args.type;
648 | 
649 |       if (!options || !options.root) {
650 |         type = namespace + type;
651 |         if ("development" !== 'production' && !store._mutations[type]) {
652 |           console.error(("[vuex] unknown local mutation type: " + (args.type) + ", global type: " + type));
653 |           return
654 |         }
655 |       }
656 | 
657 |       store.commit(type, payload, options);
658 |     }
659 |   };
660 | 
661 |   // getters and state object must be gotten lazily
662 |   // because they will be changed by vm update
663 |   Object.defineProperties(local, {
664 |     getters: {
665 |       get: noNamespace
666 |         ? function () { return store.getters; }
667 |         : function () { return makeLocalGetters(store, namespace); }
668 |     },
669 |     state: {
670 |       get: function () { return getNestedState(store.state, path); }
671 |     }
672 |   });
673 | 
674 |   return local
675 | }
676 | 
677 | function makeLocalGetters (store, namespace) {
678 |   var gettersProxy = {};
679 | 
680 |   var splitPos = namespace.length;
681 |   Object.keys(store.getters).forEach(function (type) {
682 |     // skip if the target getter is not match this namespace
683 |     if (type.slice(0, splitPos) !== namespace) { return }
684 | 
685 |     // extract local getter type
686 |     var localType = type.slice(splitPos);
687 | 
688 |     // Add a port to the getters proxy.
689 |     // Define as getter property because
690 |     // we do not want to evaluate the getters in this time.
691 |     Object.defineProperty(gettersProxy, localType, {
692 |       get: function () { return store.getters[type]; },
693 |       enumerable: true
694 |     });
695 |   });
696 | 
697 |   return gettersProxy
698 | }
699 | 
700 | function registerMutation (store, type, handler, local) {
701 |   var entry = store._mutations[type] || (store._mutations[type] = []);
702 |   entry.push(function wrappedMutationHandler (payload) {
703 |     handler.call(store, local.state, payload);
704 |   });
705 | }
706 | 
707 | function registerAction (store, type, handler, local) {
708 |   var entry = store._actions[type] || (store._actions[type] = []);
709 |   entry.push(function wrappedActionHandler (payload, cb) {
710 |     var res = handler.call(store, {
711 |       dispatch: local.dispatch,
712 |       commit: local.commit,
713 |       getters: local.getters,
714 |       state: local.state,
715 |       rootGetters: store.getters,
716 |       rootState: store.state
717 |     }, payload, cb);
718 |     if (!isPromise(res)) {
719 |       res = Promise.resolve(res);
720 |     }
721 |     if (store._devtoolHook) {
722 |       return res.catch(function (err) {
723 |         store._devtoolHook.emit('vuex:error', err);
724 |         throw err
725 |       })
726 |     } else {
727 |       return res
728 |     }
729 |   });
730 | }
731 | 
732 | function registerGetter (store, type, rawGetter, local) {
733 |   if (store._wrappedGetters[type]) {
734 |     {
735 |       console.error(("[vuex] duplicate getter key: " + type));
736 |     }
737 |     return
738 |   }
739 |   store._wrappedGetters[type] = function wrappedGetter (store) {
740 |     return rawGetter(
741 |       local.state, // local state
742 |       local.getters, // local getters
743 |       store.state, // root state
744 |       store.getters // root getters
745 |     )
746 |   };
747 | }
748 | 
749 | function enableStrictMode (store) {
750 |   store._vm.$watch(function () { return this._data.$$state }, function () {
751 |     {
752 |       assert(store._committing, "Do not mutate vuex store state outside mutation handlers.");
753 |     }
754 |   }, { deep: true, sync: true });
755 | }
756 | 
757 | function getNestedState (state, path) {
758 |   return path.length
759 |     ? path.reduce(function (state, key) { return state[key]; }, state)
760 |     : state
761 | }
762 | 
763 | function unifyObjectStyle (type, payload, options) {
764 |   if (isObject(type) && type.type) {
765 |     options = payload;
766 |     payload = type;
767 |     type = type.type;
768 |   }
769 | 
770 |   {
771 |     assert(typeof type === 'string', ("Expects string as the type, but found " + (typeof type) + "."));
772 |   }
773 | 
774 |   return { type: type, payload: payload, options: options }
775 | }
776 | 
777 | function install (_Vue) {
778 |   if (Vue && _Vue === Vue) {
779 |     {
780 |       console.error(
781 |         '[vuex] already installed. Vue.use(Vuex) should be called only once.'
782 |       );
783 |     }
784 |     return
785 |   }
786 |   Vue = _Vue;
787 |   applyMixin(Vue);
788 | }
789 | 
790 | var mapState = normalizeNamespace(function (namespace, states) {
791 |   var res = {};
792 |   normalizeMap(states).forEach(function (ref) {
793 |     var key = ref.key;
794 |     var val = ref.val;
795 | 
796 |     res[key] = function mappedState () {
797 |       var state = this.$store.state;
798 |       var getters = this.$store.getters;
799 |       if (namespace) {
800 |         var module = getModuleByNamespace(this.$store, 'mapState', namespace);
801 |         if (!module) {
802 |           return
803 |         }
804 |         state = module.context.state;
805 |         getters = module.context.getters;
806 |       }
807 |       return typeof val === 'function'
808 |         ? val.call(this, state, getters)
809 |         : state[val]
810 |     };
811 |     // mark vuex getter for devtools
812 |     res[key].vuex = true;
813 |   });
814 |   return res
815 | });
816 | 
817 | var mapMutations = normalizeNamespace(function (namespace, mutations) {
818 |   var res = {};
819 |   normalizeMap(mutations).forEach(function (ref) {
820 |     var key = ref.key;
821 |     var val = ref.val;
822 | 
823 |     res[key] = function mappedMutation () {
824 |       var args = [], len = arguments.length;
825 |       while ( len-- ) args[ len ] = arguments[ len ];
826 | 
827 |       var commit = this.$store.commit;
828 |       if (namespace) {
829 |         var module = getModuleByNamespace(this.$store, 'mapMutations', namespace);
830 |         if (!module) {
831 |           return
832 |         }
833 |         commit = module.context.commit;
834 |       }
835 |       return typeof val === 'function'
836 |         ? val.apply(this, [commit].concat(args))
837 |         : commit.apply(this.$store, [val].concat(args))
838 |     };
839 |   });
840 |   return res
841 | });
842 | 
843 | var mapGetters = normalizeNamespace(function (namespace, getters) {
844 |   var res = {};
845 |   normalizeMap(getters).forEach(function (ref) {
846 |     var key = ref.key;
847 |     var val = ref.val;
848 | 
849 |     val = namespace + val;
850 |     res[key] = function mappedGetter () {
851 |       if (namespace && !getModuleByNamespace(this.$store, 'mapGetters', namespace)) {
852 |         return
853 |       }
854 |       if ("development" !== 'production' && !(val in this.$store.getters)) {
855 |         console.error(("[vuex] unknown getter: " + val));
856 |         return
857 |       }
858 |       return this.$store.getters[val]
859 |     };
860 |     // mark vuex getter for devtools
861 |     res[key].vuex = true;
862 |   });
863 |   return res
864 | });
865 | 
866 | var mapActions = normalizeNamespace(function (namespace, actions) {
867 |   var res = {};
868 |   normalizeMap(actions).forEach(function (ref) {
869 |     var key = ref.key;
870 |     var val = ref.val;
871 | 
872 |     res[key] = function mappedAction () {
873 |       var args = [], len = arguments.length;
874 |       while ( len-- ) args[ len ] = arguments[ len ];
875 | 
876 |       var dispatch = this.$store.dispatch;
877 |       if (namespace) {
878 |         var module = getModuleByNamespace(this.$store, 'mapActions', namespace);
879 |         if (!module) {
880 |           return
881 |         }
882 |         dispatch = module.context.dispatch;
883 |       }
884 |       return typeof val === 'function'
885 |         ? val.apply(this, [dispatch].concat(args))
886 |         : dispatch.apply(this.$store, [val].concat(args))
887 |     };
888 |   });
889 |   return res
890 | });
891 | 
892 | var createNamespacedHelpers = function (namespace) { return ({
893 |   mapState: mapState.bind(null, namespace),
894 |   mapGetters: mapGetters.bind(null, namespace),
895 |   mapMutations: mapMutations.bind(null, namespace),
896 |   mapActions: mapActions.bind(null, namespace)
897 | }); };
898 | 
899 | function normalizeMap (map) {
900 |   return Array.isArray(map)
901 |     ? map.map(function (key) { return ({ key: key, val: key }); })
902 |     : Object.keys(map).map(function (key) { return ({ key: key, val: map[key] }); })
903 | }
904 | 
905 | function normalizeNamespace (fn) {
906 |   return function (namespace, map) {
907 |     if (typeof namespace !== 'string') {
908 |       map = namespace;
909 |       namespace = '';
910 |     } else if (namespace.charAt(namespace.length - 1) !== '/') {
911 |       namespace += '/';
912 |     }
913 |     return fn(namespace, map)
914 |   }
915 | }
916 | 
917 | function getModuleByNamespace (store, helper, namespace) {
918 |   var module = store._modulesNamespaceMap[namespace];
919 |   if ("development" !== 'production' && !module) {
920 |     console.error(("[vuex] module namespace not found in " + helper + "(): " + namespace));
921 |   }
922 |   return module
923 | }
924 | 
925 | var index = {
926 |   Store: Store,
927 |   install: install,
928 |   version: '3.0.1',
929 |   mapState: mapState,
930 |   mapMutations: mapMutations,
931 |   mapGetters: mapGetters,
932 |   mapActions: mapActions,
933 |   createNamespacedHelpers: createNamespacedHelpers
934 | };
935 | 
936 | return index;
937 | 
938 | })));
939 | 


--------------------------------------------------------------------------------
/vendor/assets/javascripts/dist/vuex.min.js:
--------------------------------------------------------------------------------
1 | /**
2 |  * vuex v3.0.1
3 |  * (c) 2017 Evan You
4 |  * @license MIT
5 |  */
6 | !function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):t.Vuex=e()}(this,function(){"use strict";function t(t){$&&(t._devtoolHook=$,$.emit("vuex:init",t),$.on("vuex:travel-to-state",function(e){t.replaceState(e)}),t.subscribe(function(t,e){$.emit("vuex:mutation",t,e)}))}function e(t,e){Object.keys(t).forEach(function(n){return e(t[n],n)})}function n(t){return null!==t&&"object"==typeof t}function o(t){return t&&"function"==typeof t.then}function i(t,e,n){if(e.update(n),n.modules)for(var o in n.modules){if(!e.getChild(o))return;i(t.concat(o),e.getChild(o),n.modules[o])}}function r(t,e){return e.indexOf(t)<0&&e.push(t),function(){var n=e.indexOf(t);n>-1&&e.splice(n,1)}}function s(t,e){t._actions=Object.create(null),t._mutations=Object.create(null),t._wrappedGetters=Object.create(null),t._modulesNamespaceMap=Object.create(null);var n=t.state;a(t,n,[],t._modules.root,!0),c(t,n,e)}function c(t,n,o){var i=t._vm;t.getters={};var r={};e(t._wrappedGetters,function(e,n){r[n]=function(){return e(t)},Object.defineProperty(t.getters,n,{get:function(){return t._vm[n]},enumerable:!0})});var s=j.config.silent;j.config.silent=!0,t._vm=new j({data:{$$state:n},computed:r}),j.config.silent=s,t.strict&&d(t),i&&(o&&t._withCommit(function(){i._data.$$state=null}),j.nextTick(function(){return i.$destroy()}))}function a(t,e,n,o,i){var r=!n.length,s=t._modules.getNamespace(n);if(o.namespaced&&(t._modulesNamespaceMap[s]=o),!r&&!i){var c=m(e,n.slice(0,-1)),f=n[n.length-1];t._withCommit(function(){j.set(c,f,o.state)})}var d=o.context=u(t,s,n);o.forEachMutation(function(e,n){p(t,s+n,e,d)}),o.forEachAction(function(e,n){var o=e.root?n:s+n,i=e.handler||e;h(t,o,i,d)}),o.forEachGetter(function(e,n){l(t,s+n,e,d)}),o.forEachChild(function(o,r){a(t,e,n.concat(r),o,i)})}function u(t,e,n){var o=""===e,i={dispatch:o?t.dispatch:function(n,o,i){var r=v(n,o,i),s=r.payload,c=r.options,a=r.type;return c&&c.root||(a=e+a),t.dispatch(a,s)},commit:o?t.commit:function(n,o,i){var r=v(n,o,i),s=r.payload,c=r.options,a=r.type;c&&c.root||(a=e+a),t.commit(a,s,c)}};return Object.defineProperties(i,{getters:{get:o?function(){return t.getters}:function(){return f(t,e)}},state:{get:function(){return m(t.state,n)}}}),i}function f(t,e){var n={},o=e.length;return Object.keys(t.getters).forEach(function(i){if(i.slice(0,o)===e){var r=i.slice(o);Object.defineProperty(n,r,{get:function(){return t.getters[i]},enumerable:!0})}}),n}function p(t,e,n,o){(t._mutations[e]||(t._mutations[e]=[])).push(function(e){n.call(t,o.state,e)})}function h(t,e,n,i){(t._actions[e]||(t._actions[e]=[])).push(function(e,r){var s=n.call(t,{dispatch:i.dispatch,commit:i.commit,getters:i.getters,state:i.state,rootGetters:t.getters,rootState:t.state},e,r);return o(s)||(s=Promise.resolve(s)),t._devtoolHook?s.catch(function(e){throw t._devtoolHook.emit("vuex:error",e),e}):s})}function l(t,e,n,o){t._wrappedGetters[e]||(t._wrappedGetters[e]=function(t){return n(o.state,o.getters,t.state,t.getters)})}function d(t){t._vm.$watch(function(){return this._data.$$state},function(){},{deep:!0,sync:!0})}function m(t,e){return e.length?e.reduce(function(t,e){return t[e]},t):t}function v(t,e,o){return n(t)&&t.type&&(o=e,e=t,t=t.type),{type:t,payload:e,options:o}}function _(t){j&&t===j||w(j=t)}function y(t){return Array.isArray(t)?t.map(function(t){return{key:t,val:t}}):Object.keys(t).map(function(e){return{key:e,val:t[e]}})}function g(t){return function(e,n){return"string"!=typeof e?(n=e,e=""):"/"!==e.charAt(e.length-1)&&(e+="/"),t(e,n)}}function b(t,e,n){var o=t._modulesNamespaceMap[n];return o}var w=function(t){function e(){var t=this.$options;t.store?this.$store="function"==typeof t.store?t.store():t.store:t.parent&&t.parent.$store&&(this.$store=t.parent.$store)}if(Number(t.version.split(".")[0])>=2)t.mixin({beforeCreate:e});else{var n=t.prototype._init;t.prototype._init=function(t){void 0===t&&(t={}),t.init=t.init?[e].concat(t.init):e,n.call(this,t)}}},$="undefined"!=typeof window&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__,M=function(t,e){this.runtime=e,this._children=Object.create(null),this._rawModule=t;var n=t.state;this.state=("function"==typeof n?n():n)||{}},O={namespaced:{configurable:!0}};O.namespaced.get=function(){return!!this._rawModule.namespaced},M.prototype.addChild=function(t,e){this._children[t]=e},M.prototype.removeChild=function(t){delete this._children[t]},M.prototype.getChild=function(t){return this._children[t]},M.prototype.update=function(t){this._rawModule.namespaced=t.namespaced,t.actions&&(this._rawModule.actions=t.actions),t.mutations&&(this._rawModule.mutations=t.mutations),t.getters&&(this._rawModule.getters=t.getters)},M.prototype.forEachChild=function(t){e(this._children,t)},M.prototype.forEachGetter=function(t){this._rawModule.getters&&e(this._rawModule.getters,t)},M.prototype.forEachAction=function(t){this._rawModule.actions&&e(this._rawModule.actions,t)},M.prototype.forEachMutation=function(t){this._rawModule.mutations&&e(this._rawModule.mutations,t)},Object.defineProperties(M.prototype,O);var E=function(t){this.register([],t,!1)};E.prototype.get=function(t){return t.reduce(function(t,e){return t.getChild(e)},this.root)},E.prototype.getNamespace=function(t){var e=this.root;return t.reduce(function(t,n){return e=e.getChild(n),t+(e.namespaced?n+"/":"")},"")},E.prototype.update=function(t){i([],this.root,t)},E.prototype.register=function(t,n,o){var i=this;void 0===o&&(o=!0);var r=new M(n,o);0===t.length?this.root=r:this.get(t.slice(0,-1)).addChild(t[t.length-1],r),n.modules&&e(n.modules,function(e,n){i.register(t.concat(n),e,o)})},E.prototype.unregister=function(t){var e=this.get(t.slice(0,-1)),n=t[t.length-1];e.getChild(n).runtime&&e.removeChild(n)};var j,C=function(e){var n=this;void 0===e&&(e={}),!j&&"undefined"!=typeof window&&window.Vue&&_(window.Vue);var o=e.plugins;void 0===o&&(o=[]);var i=e.strict;void 0===i&&(i=!1);var r=e.state;void 0===r&&(r={}),"function"==typeof r&&(r=r()||{}),this._committing=!1,this._actions=Object.create(null),this._actionSubscribers=[],this._mutations=Object.create(null),this._wrappedGetters=Object.create(null),this._modules=new E(e),this._modulesNamespaceMap=Object.create(null),this._subscribers=[],this._watcherVM=new j;var s=this,u=this,f=u.dispatch,p=u.commit;this.dispatch=function(t,e){return f.call(s,t,e)},this.commit=function(t,e,n){return p.call(s,t,e,n)},this.strict=i,a(this,r,[],this._modules.root),c(this,r),o.forEach(function(t){return t(n)}),j.config.devtools&&t(this)},x={state:{configurable:!0}};x.state.get=function(){return this._vm._data.$$state},x.state.set=function(t){},C.prototype.commit=function(t,e,n){var o=this,i=v(t,e,n),r=i.type,s=i.payload,c=(i.options,{type:r,payload:s}),a=this._mutations[r];a&&(this._withCommit(function(){a.forEach(function(t){t(s)})}),this._subscribers.forEach(function(t){return t(c,o.state)}))},C.prototype.dispatch=function(t,e){var n=this,o=v(t,e),i=o.type,r=o.payload,s={type:i,payload:r},c=this._actions[i];if(c)return this._actionSubscribers.forEach(function(t){return t(s,n.state)}),c.length>1?Promise.all(c.map(function(t){return t(r)})):c[0](r)},C.prototype.subscribe=function(t){return r(t,this._subscribers)},C.prototype.subscribeAction=function(t){return r(t,this._actionSubscribers)},C.prototype.watch=function(t,e,n){var o=this;return this._watcherVM.$watch(function(){return t(o.state,o.getters)},e,n)},C.prototype.replaceState=function(t){var e=this;this._withCommit(function(){e._vm._data.$$state=t})},C.prototype.registerModule=function(t,e,n){void 0===n&&(n={}),"string"==typeof t&&(t=[t]),this._modules.register(t,e),a(this,this.state,t,this._modules.get(t),n.preserveState),c(this,this.state)},C.prototype.unregisterModule=function(t){var e=this;"string"==typeof t&&(t=[t]),this._modules.unregister(t),this._withCommit(function(){var n=m(e.state,t.slice(0,-1));j.delete(n,t[t.length-1])}),s(this)},C.prototype.hotUpdate=function(t){this._modules.update(t),s(this,!0)},C.prototype._withCommit=function(t){var e=this._committing;this._committing=!0,t(),this._committing=e},Object.defineProperties(C.prototype,x);var k=g(function(t,e){var n={};return y(e).forEach(function(e){var o=e.key,i=e.val;n[o]=function(){var e=this.$store.state,n=this.$store.getters;if(t){var o=b(this.$store,0,t);if(!o)return;e=o.context.state,n=o.context.getters}return"function"==typeof i?i.call(this,e,n):e[i]},n[o].vuex=!0}),n}),G=g(function(t,e){var n={};return y(e).forEach(function(e){var o=e.key,i=e.val;n[o]=function(){for(var e=[],n=arguments.length;n--;)e[n]=arguments[n];var o=this.$store.commit;if(t){var r=b(this.$store,0,t);if(!r)return;o=r.context.commit}return"function"==typeof i?i.apply(this,[o].concat(e)):o.apply(this.$store,[i].concat(e))}}),n}),S=g(function(t,e){var n={};return y(e).forEach(function(e){var o=e.key,i=e.val;i=t+i,n[o]=function(){if(!t||b(this.$store,0,t))return this.$store.getters[i]},n[o].vuex=!0}),n}),A=g(function(t,e){var n={};return y(e).forEach(function(e){var o=e.key,i=e.val;n[o]=function(){for(var e=[],n=arguments.length;n--;)e[n]=arguments[n];var o=this.$store.dispatch;if(t){var r=b(this.$store,0,t);if(!r)return;o=r.context.dispatch}return"function"==typeof i?i.apply(this,[o].concat(e)):o.apply(this.$store,[i].concat(e))}}),n});return{Store:C,install:_,version:"3.0.1",mapState:k,mapMutations:G,mapGetters:S,mapActions:A,createNamespacedHelpers:function(t){return{mapState:k.bind(null,t),mapGetters:S.bind(null,t),mapMutations:G.bind(null,t),mapActions:A.bind(null,t)}}}});


--------------------------------------------------------------------------------
/vendor/assets/javascripts/vue-resource.js.erb:
--------------------------------------------------------------------------------
1 | <%= require_asset Vue.full_or_minified('vue-resource') %>
2 | 


--------------------------------------------------------------------------------
/vendor/assets/javascripts/vue-router.js.erb:
--------------------------------------------------------------------------------
1 | <%= require_asset Vue.full_or_minified('vue-router') %>
2 | 


--------------------------------------------------------------------------------
/vendor/assets/javascripts/vue.js.erb:
--------------------------------------------------------------------------------
1 | <%= require_asset Vue.full_or_minified('vue') %>
2 | 


--------------------------------------------------------------------------------
/vendor/assets/javascripts/vuex.js.erb:
--------------------------------------------------------------------------------
1 | <%= require_asset Vue.full_or_minified('vuex') %>
2 | 


--------------------------------------------------------------------------------
/vuejs-rails.gemspec:
--------------------------------------------------------------------------------
 1 | # -*- encoding: utf-8 -*-
 2 | $:.push File.expand_path("../lib", __FILE__)
 3 | require "vuejs-rails/version"
 4 | 
 5 | Gem::Specification.new do |s|
 6 |   s.name        = "vuejs-rails"
 7 |   s.version     = Vue::Rails::VERSION
 8 |   s.authors     = ["Adam Butler"]
 9 |   s.email       = ["adam@lab.io"]
10 |   s.homepage    = "https://github.com/adambutler/vuejs-rails"
11 |   s.summary     = %q{vue.js asset pipeline provider/wrapper}
12 |   s.description = "A simple asset-pipeline wrapper for vue.js by Evan You"
13 |   s.license     = "MIT"
14 | 
15 |   s.rubyforge_project = "vuejs-rails"
16 | 
17 |   s.files         = `git ls-files`.split("\n")
18 |   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
19 |   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
20 |   s.require_paths = ["lib"]
21 | 
22 | end
23 | 


--------------------------------------------------------------------------------