mirror of
https://github.com/tenrok/vue-select.git
synced 2026-06-10 07:52:23 +03:00
Jeff Sagal
22629 lines
1.6 MiB
Plaintext
22629 lines
1.6 MiB
Plaintext
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({2:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/after/index.js", module);
|
||
(function(){
|
||
module.exports = after
|
||
|
||
function after(count, callback, err_cb) {
|
||
var bail = false
|
||
err_cb = err_cb || noop
|
||
proxy.count = count
|
||
|
||
return (count === 0) ? callback() : proxy
|
||
|
||
function proxy(err, result) {
|
||
if (proxy.count <= 0) {
|
||
throw new Error('after called too many times')
|
||
}
|
||
--proxy.count
|
||
|
||
// after first error, rest are passed to err_cb
|
||
if (err) {
|
||
bail = true
|
||
callback(err)
|
||
// future error callbacks will go to error handler
|
||
callback = err_cb
|
||
} else if (proxy.count === 0 && !bail) {
|
||
callback(null, result)
|
||
}
|
||
}
|
||
}
|
||
|
||
function noop() {}
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],3:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/arraybuffer.slice/index.js", module);
|
||
(function(){
|
||
/**
|
||
* An abstraction for slicing an arraybuffer even when
|
||
* ArrayBuffer.prototype.slice is not supported
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
module.exports = function(arraybuffer, start, end) {
|
||
var bytes = arraybuffer.byteLength;
|
||
start = start || 0;
|
||
end = end || bytes;
|
||
|
||
if (arraybuffer.slice) { return arraybuffer.slice(start, end); }
|
||
|
||
if (start < 0) { start += bytes; }
|
||
if (end < 0) { end += bytes; }
|
||
if (end > bytes) { end = bytes; }
|
||
|
||
if (start >= bytes || start >= end || bytes === 0) {
|
||
return new ArrayBuffer(0);
|
||
}
|
||
|
||
var abv = new Uint8Array(arraybuffer);
|
||
var result = new Uint8Array(end - start);
|
||
for (var i = start, ii = 0; i < end; i++, ii++) {
|
||
result[ii] = abv[i];
|
||
}
|
||
return result.buffer;
|
||
};
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],4:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/babel-runtime/core-js/symbol.js", module);
|
||
(function(){
|
||
module.exports = { "default": require("core-js/library/fn/symbol"), __esModule: true };
|
||
}).apply(this, arguments);
|
||
|
||
},{"core-js/library/fn/symbol":16}],5:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/babel-runtime/helpers/typeof.js", module);
|
||
(function(){
|
||
"use strict";
|
||
|
||
var _Symbol = require("babel-runtime/core-js/symbol")["default"];
|
||
|
||
exports["default"] = function (obj) {
|
||
return obj && obj.constructor === _Symbol ? "symbol" : typeof obj;
|
||
};
|
||
|
||
exports.__esModule = true;
|
||
}).apply(this, arguments);
|
||
|
||
},{"babel-runtime/core-js/symbol":4}],6:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/backo2/index.js", module);
|
||
(function(){
|
||
|
||
/**
|
||
* Expose `Backoff`.
|
||
*/
|
||
|
||
module.exports = Backoff;
|
||
|
||
/**
|
||
* Initialize backoff timer with `opts`.
|
||
*
|
||
* - `min` initial timeout in milliseconds [100]
|
||
* - `max` max timeout [10000]
|
||
* - `jitter` [0]
|
||
* - `factor` [2]
|
||
*
|
||
* @param {Object} opts
|
||
* @api public
|
||
*/
|
||
|
||
function Backoff(opts) {
|
||
opts = opts || {};
|
||
this.ms = opts.min || 100;
|
||
this.max = opts.max || 10000;
|
||
this.factor = opts.factor || 2;
|
||
this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
|
||
this.attempts = 0;
|
||
}
|
||
|
||
/**
|
||
* Return the backoff duration.
|
||
*
|
||
* @return {Number}
|
||
* @api public
|
||
*/
|
||
|
||
Backoff.prototype.duration = function(){
|
||
var ms = this.ms * Math.pow(this.factor, this.attempts++);
|
||
if (this.jitter) {
|
||
var rand = Math.random();
|
||
var deviation = Math.floor(rand * this.jitter * ms);
|
||
ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
|
||
}
|
||
return Math.min(ms, this.max) | 0;
|
||
};
|
||
|
||
/**
|
||
* Reset the number of attempts.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Backoff.prototype.reset = function(){
|
||
this.attempts = 0;
|
||
};
|
||
|
||
/**
|
||
* Set the minimum duration
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Backoff.prototype.setMin = function(min){
|
||
this.ms = min;
|
||
};
|
||
|
||
/**
|
||
* Set the maximum duration
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Backoff.prototype.setMax = function(max){
|
||
this.max = max;
|
||
};
|
||
|
||
/**
|
||
* Set the jitter
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Backoff.prototype.setJitter = function(jitter){
|
||
this.jitter = jitter;
|
||
};
|
||
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],7:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/base64-arraybuffer/lib/base64-arraybuffer.js", module);
|
||
(function(){
|
||
/*
|
||
* base64-arraybuffer
|
||
* https://github.com/niklasvh/base64-arraybuffer
|
||
*
|
||
* Copyright (c) 2012 Niklas von Hertzen
|
||
* Licensed under the MIT license.
|
||
*/
|
||
(function(chars){
|
||
"use strict";
|
||
|
||
exports.encode = function(arraybuffer) {
|
||
var bytes = new Uint8Array(arraybuffer),
|
||
i, len = bytes.length, base64 = "";
|
||
|
||
for (i = 0; i < len; i+=3) {
|
||
base64 += chars[bytes[i] >> 2];
|
||
base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
|
||
base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
|
||
base64 += chars[bytes[i + 2] & 63];
|
||
}
|
||
|
||
if ((len % 3) === 2) {
|
||
base64 = base64.substring(0, base64.length - 1) + "=";
|
||
} else if (len % 3 === 1) {
|
||
base64 = base64.substring(0, base64.length - 2) + "==";
|
||
}
|
||
|
||
return base64;
|
||
};
|
||
|
||
exports.decode = function(base64) {
|
||
var bufferLength = base64.length * 0.75,
|
||
len = base64.length, i, p = 0,
|
||
encoded1, encoded2, encoded3, encoded4;
|
||
|
||
if (base64[base64.length - 1] === "=") {
|
||
bufferLength--;
|
||
if (base64[base64.length - 2] === "=") {
|
||
bufferLength--;
|
||
}
|
||
}
|
||
|
||
var arraybuffer = new ArrayBuffer(bufferLength),
|
||
bytes = new Uint8Array(arraybuffer);
|
||
|
||
for (i = 0; i < len; i+=4) {
|
||
encoded1 = chars.indexOf(base64[i]);
|
||
encoded2 = chars.indexOf(base64[i+1]);
|
||
encoded3 = chars.indexOf(base64[i+2]);
|
||
encoded4 = chars.indexOf(base64[i+3]);
|
||
|
||
bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
|
||
bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
|
||
bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
|
||
}
|
||
|
||
return arraybuffer;
|
||
};
|
||
})("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],8:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/blob/index.js", module);
|
||
(function(){
|
||
(function (global){
|
||
/**
|
||
* Create a blob builder even when vendor prefixes exist
|
||
*/
|
||
|
||
var BlobBuilder = global.BlobBuilder
|
||
|| global.WebKitBlobBuilder
|
||
|| global.MSBlobBuilder
|
||
|| global.MozBlobBuilder;
|
||
|
||
/**
|
||
* Check if Blob constructor is supported
|
||
*/
|
||
|
||
var blobSupported = (function() {
|
||
try {
|
||
var a = new Blob(['hi']);
|
||
return a.size === 2;
|
||
} catch(e) {
|
||
return false;
|
||
}
|
||
})();
|
||
|
||
/**
|
||
* Check if Blob constructor supports ArrayBufferViews
|
||
* Fails in Safari 6, so we need to map to ArrayBuffers there.
|
||
*/
|
||
|
||
var blobSupportsArrayBufferView = blobSupported && (function() {
|
||
try {
|
||
var b = new Blob([new Uint8Array([1,2])]);
|
||
return b.size === 2;
|
||
} catch(e) {
|
||
return false;
|
||
}
|
||
})();
|
||
|
||
/**
|
||
* Check if BlobBuilder is supported
|
||
*/
|
||
|
||
var blobBuilderSupported = BlobBuilder
|
||
&& BlobBuilder.prototype.append
|
||
&& BlobBuilder.prototype.getBlob;
|
||
|
||
/**
|
||
* Helper function that maps ArrayBufferViews to ArrayBuffers
|
||
* Used by BlobBuilder constructor and old browsers that didn't
|
||
* support it in the Blob constructor.
|
||
*/
|
||
|
||
function mapArrayBufferViews(ary) {
|
||
for (var i = 0; i < ary.length; i++) {
|
||
var chunk = ary[i];
|
||
if (chunk.buffer instanceof ArrayBuffer) {
|
||
var buf = chunk.buffer;
|
||
|
||
// if this is a subarray, make a copy so we only
|
||
// include the subarray region from the underlying buffer
|
||
if (chunk.byteLength !== buf.byteLength) {
|
||
var copy = new Uint8Array(chunk.byteLength);
|
||
copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));
|
||
buf = copy.buffer;
|
||
}
|
||
|
||
ary[i] = buf;
|
||
}
|
||
}
|
||
}
|
||
|
||
function BlobBuilderConstructor(ary, options) {
|
||
options = options || {};
|
||
|
||
var bb = new BlobBuilder();
|
||
mapArrayBufferViews(ary);
|
||
|
||
for (var i = 0; i < ary.length; i++) {
|
||
bb.append(ary[i]);
|
||
}
|
||
|
||
return (options.type) ? bb.getBlob(options.type) : bb.getBlob();
|
||
};
|
||
|
||
function BlobConstructor(ary, options) {
|
||
mapArrayBufferViews(ary);
|
||
return new Blob(ary, options || {});
|
||
};
|
||
|
||
module.exports = (function() {
|
||
if (blobSupported) {
|
||
return blobSupportsArrayBufferView ? global.Blob : BlobConstructor;
|
||
} else if (blobBuilderSupported) {
|
||
return BlobBuilderConstructor;
|
||
} else {
|
||
return undefined;
|
||
}
|
||
})();
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],9:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/browser-resolve/empty.js", module);
|
||
(function(){
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],10:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/browserify-hmr/inc/index.js", module);
|
||
(function(){
|
||
(function (global){
|
||
'use strict';
|
||
|
||
var has = require('../lib/has');
|
||
var StrSet = require('../lib/str-set');
|
||
var forEach = require('lodash/collection/forEach');
|
||
var some = require('lodash/collection/some');
|
||
var map = require('lodash/collection/map');
|
||
var filter = require('lodash/collection/filter');
|
||
var zipObject = require('lodash/array/zipObject');
|
||
var forOwn = require('lodash/object/forOwn');
|
||
var mapValues = require('lodash/object/mapValues');
|
||
var assign = require('lodash/object/assign');
|
||
|
||
function emitError(err) {
|
||
setTimeout(function() {
|
||
throw err;
|
||
}, 0);
|
||
}
|
||
|
||
function makeModuleIndexesToNames(moduleMeta) {
|
||
var moduleIndexesToNames = {};
|
||
forOwn(moduleMeta, function(value, name) {
|
||
moduleIndexesToNames[value.index] = name;
|
||
});
|
||
return moduleIndexesToNames;
|
||
}
|
||
|
||
var console = global.console ? global.console : {
|
||
error: function(){}, log: function() {}
|
||
};
|
||
|
||
function main(
|
||
moduleDefs, cachedModules, moduleMeta, updateUrl,
|
||
updateMode, supportModes, ignoreUnaccepted, updateCacheBust, bundleKey,
|
||
socketio,
|
||
bundle__filename, bundle__dirname
|
||
) {
|
||
var moduleIndexesToNames = makeModuleIndexesToNames(moduleMeta);
|
||
|
||
var socket;
|
||
var name, i, len;
|
||
|
||
if (!global._hmr[bundleKey].setStatus) {
|
||
var runtimeModuleInfo = {};
|
||
var createInfoEntry = function(name) {
|
||
runtimeModuleInfo[name] = {
|
||
index: moduleMeta[name].index,
|
||
hash: moduleMeta[name].hash,
|
||
parents: new StrSet(moduleMeta[name].parents),
|
||
module: null,
|
||
disposeData: null,
|
||
accepters: new StrSet(),
|
||
accepting: new StrSet(),
|
||
decliners: new StrSet(),
|
||
declining: new StrSet(),
|
||
selfAcceptCbs: [], // may contain null. nonzero length means module is self-accepting
|
||
disposeHandlers: []
|
||
};
|
||
};
|
||
for (name in moduleMeta) {
|
||
if (has(moduleMeta, name)) {
|
||
createInfoEntry(name);
|
||
}
|
||
}
|
||
|
||
// loaders take a callback(err, data). They may give null for data if they
|
||
// know there hasn't been an update.
|
||
var fileReloaders = {
|
||
fs: function(cb) {
|
||
var fs;
|
||
try {
|
||
fs = require('f'+'s');
|
||
} catch(e) {
|
||
cb(e);
|
||
return;
|
||
}
|
||
fs.readFile(localHmr.updateUrl || bundle__filename, 'utf8', cb);
|
||
},
|
||
ajax: function(cb) {
|
||
var xhr;
|
||
try {
|
||
xhr = new XMLHttpRequest();
|
||
} catch(e) {
|
||
cb(e);
|
||
return;
|
||
}
|
||
xhr.onreadystatechange = function() {
|
||
if (xhr.readyState === 4) {
|
||
if (xhr.status === 200) {
|
||
cb(null, xhr.responseText);
|
||
} else {
|
||
cb(new Error("Request had response "+xhr.status));
|
||
}
|
||
}
|
||
};
|
||
var url = localHmr.updateUrl + (updateCacheBust?'?_v='+(+new Date()):'');
|
||
xhr.open('GET', url, true);
|
||
xhr.send();
|
||
}
|
||
};
|
||
|
||
var lastScriptData = null;
|
||
|
||
// cb(err, expectUpdate)
|
||
var reloadAndRunScript = function(cb) {
|
||
if (!has(fileReloaders, localHmr.updateMode)) {
|
||
cb(new Error("updateMode "+localHmr.updateMode+" not implemented"));
|
||
return;
|
||
}
|
||
var reloader = fileReloaders[localHmr.updateMode];
|
||
reloader(function(err, data) {
|
||
if (err || !data || lastScriptData === data) {
|
||
cb(err, false);
|
||
return;
|
||
}
|
||
lastScriptData = data;
|
||
localHmr.newLoad = null;
|
||
try {
|
||
//jshint evil:true
|
||
if (bundle__filename || bundle__dirname) {
|
||
new Function('require', '__filename', '__dirname', data)(require, bundle__filename, bundle__dirname);
|
||
} else {
|
||
new Function('require', data)(require);
|
||
}
|
||
// running the file sets _hmr.newLoad
|
||
} catch (err2) {
|
||
localHmr.newLoad = null;
|
||
cb(err2);
|
||
return;
|
||
}
|
||
if (!localHmr.newLoad) {
|
||
cb(new Error("Reloaded script did not set hot module reload data"));
|
||
return;
|
||
}
|
||
cb(null, true);
|
||
});
|
||
};
|
||
|
||
var getOutdatedModules = function() {
|
||
var outdated = [];
|
||
var name;
|
||
// add changed and deleted modules
|
||
for (name in runtimeModuleInfo) {
|
||
if (has(runtimeModuleInfo, name)) {
|
||
if (
|
||
!has(localHmr.newLoad.moduleMeta, name) ||
|
||
runtimeModuleInfo[name].hash !== localHmr.newLoad.moduleMeta[name].hash
|
||
) {
|
||
outdated.push(name);
|
||
}
|
||
}
|
||
}
|
||
// add brand new modules
|
||
for (name in localHmr.newLoad.moduleMeta) {
|
||
if (has(localHmr.newLoad.moduleMeta, name)) {
|
||
if (!has(runtimeModuleInfo, name)) {
|
||
outdated.push(name);
|
||
}
|
||
}
|
||
}
|
||
// add modules that are non-accepting/declining parents of outdated modules.
|
||
// important: if outdated has new elements added during the loop,
|
||
// then we iterate over them too.
|
||
for (var i=0; i<outdated.length; i++) {
|
||
name = outdated[i];
|
||
//jshint -W083
|
||
if (has(runtimeModuleInfo, name)) {
|
||
runtimeModuleInfo[name].parents.forEach(function(parentName) {
|
||
if (
|
||
runtimeModuleInfo[name].selfAcceptCbs.length === 0 &&
|
||
!runtimeModuleInfo[name].accepters.has(parentName) &&
|
||
!runtimeModuleInfo[name].decliners.has(parentName) &&
|
||
outdated.indexOf(parentName) === -1
|
||
) {
|
||
outdated.push(parentName);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
return outdated;
|
||
};
|
||
|
||
var moduleHotCheck = function(autoApply, cb) {
|
||
if (typeof autoApply === 'function') {
|
||
cb = autoApply;
|
||
autoApply = false;
|
||
}
|
||
if (!cb) {
|
||
throw new Error("module.hot.check callback parameter required");
|
||
}
|
||
if (localHmr.status !== 'idle') {
|
||
cb(new Error("module.hot.check can only be called while status is idle"));
|
||
return;
|
||
}
|
||
if (updateMode === 'websocket') {
|
||
cb(new Error("module.hot.check can't be used when update mode is websocket"));
|
||
return;
|
||
}
|
||
|
||
localHmr.setStatus('check');
|
||
reloadAndRunScript(function(err, expectUpdate) {
|
||
if (err || !expectUpdate) {
|
||
localHmr.setStatus('idle');
|
||
cb(err, null);
|
||
return;
|
||
}
|
||
var outdatedModules = getOutdatedModules();
|
||
if (outdatedModules.length === 0) {
|
||
localHmr.setStatus('idle');
|
||
cb(null, null);
|
||
} else {
|
||
localHmr.setStatus('ready');
|
||
if (autoApply) {
|
||
moduleHotApply(autoApply, cb);
|
||
} else {
|
||
cb(null, outdatedModules);
|
||
}
|
||
}
|
||
});
|
||
};
|
||
|
||
var moduleHotApply = function(options, cb) {
|
||
if (typeof options === 'function') {
|
||
cb = options;
|
||
options = null;
|
||
}
|
||
if (!cb) {
|
||
throw new Error("module.hot.apply callback parameter required");
|
||
}
|
||
var ignoreUnaccepted = !!(options && options.ignoreUnaccepted);
|
||
if (localHmr.status !== 'ready') {
|
||
cb(new Error("module.hot.apply can only be called while status is ready"));
|
||
return;
|
||
}
|
||
|
||
var outdatedModules = getOutdatedModules();
|
||
var isValueNotInOutdatedModules = function(value) {
|
||
return outdatedModules.indexOf(value) === -1;
|
||
};
|
||
var i, len;
|
||
var acceptedUpdates = filter(outdatedModules, function(name) {
|
||
if (has(runtimeModuleInfo, name)) {
|
||
if (
|
||
runtimeModuleInfo[name].decliners.some(isValueNotInOutdatedModules) ||
|
||
(
|
||
runtimeModuleInfo[name].accepters.size() === 0 &&
|
||
runtimeModuleInfo[name].selfAcceptCbs.length === 0 &&
|
||
runtimeModuleInfo[name].parents.some(isValueNotInOutdatedModules)
|
||
)
|
||
) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
});
|
||
if (!ignoreUnaccepted && outdatedModules.length !== acceptedUpdates.length) {
|
||
localHmr.setStatus('idle');
|
||
cb(new Error("Some updates were declined"));
|
||
return;
|
||
}
|
||
var an;
|
||
for (i=0, len=acceptedUpdates.length; i<len; i++) {
|
||
an = acceptedUpdates[i];
|
||
if (has(runtimeModuleInfo, an)) {
|
||
runtimeModuleInfo[an].disposeData = {};
|
||
for (var j=0; j<runtimeModuleInfo[an].disposeHandlers.length; j++) {
|
||
try {
|
||
runtimeModuleInfo[an].disposeHandlers[j].call(null, runtimeModuleInfo[an].disposeData);
|
||
} catch(e) {
|
||
localHmr.setStatus('idle');
|
||
cb(e || new Error("Unknown dispose callback error"));
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
var selfAccepters = [];
|
||
for (i=0, len=acceptedUpdates.length; i<len; i++) {
|
||
an = acceptedUpdates[i];
|
||
//jshint -W083
|
||
if (!has(runtimeModuleInfo, an)) {
|
||
// new modules
|
||
runtimeModuleInfo[an] = {
|
||
index: an,
|
||
hash: localHmr.newLoad.moduleMeta[an].hash,
|
||
parents: new StrSet(localHmr.newLoad.moduleMeta[an].parents),
|
||
module: null,
|
||
disposeData: null,
|
||
accepters: new StrSet(),
|
||
accepting: new StrSet(),
|
||
decliners: new StrSet(),
|
||
declining: new StrSet(),
|
||
selfAcceptCbs: [],
|
||
disposeHandlers: []
|
||
};
|
||
} else if (!has(localHmr.newLoad.moduleMeta, an)) {
|
||
// removed modules
|
||
delete cachedModules[runtimeModuleInfo[an].index];
|
||
delete runtimeModuleInfo[an];
|
||
continue;
|
||
} else {
|
||
// updated modules
|
||
runtimeModuleInfo[an].hash = localHmr.newLoad.moduleMeta[an].hash;
|
||
runtimeModuleInfo[an].parents = new StrSet(localHmr.newLoad.moduleMeta[an].parents);
|
||
runtimeModuleInfo[an].module = null;
|
||
runtimeModuleInfo[an].accepting.forEach(function(accepted) {
|
||
runtimeModuleInfo[accepted].accepters.del(an);
|
||
});
|
||
runtimeModuleInfo[an].accepting = new StrSet();
|
||
runtimeModuleInfo[an].declining.forEach(function(accepted) {
|
||
runtimeModuleInfo[accepted].decliners.del(an);
|
||
});
|
||
runtimeModuleInfo[an].declining = new StrSet();
|
||
forEach(runtimeModuleInfo[an].selfAcceptCbs, function(cb) {
|
||
selfAccepters.push({name: an, cb: cb});
|
||
});
|
||
runtimeModuleInfo[an].selfAcceptCbs = [];
|
||
runtimeModuleInfo[an].disposeHandlers = [];
|
||
}
|
||
|
||
moduleDefs[runtimeModuleInfo[an].index] = [
|
||
// module function
|
||
localHmr.newLoad.moduleDefs[localHmr.newLoad.moduleMeta[an].index][0],
|
||
// module deps
|
||
mapValues(localHmr.newLoad.moduleDefs[localHmr.newLoad.moduleMeta[an].index][1], function(depIndex, depRef) {
|
||
var depName = localHmr.newLoad.moduleIndexesToNames[depIndex];
|
||
if (has(localHmr.runtimeModuleInfo, depName)) {
|
||
return localHmr.runtimeModuleInfo[depName].index;
|
||
} else {
|
||
return depName;
|
||
}
|
||
})
|
||
];
|
||
cachedModules[runtimeModuleInfo[an].index] = null;
|
||
}
|
||
|
||
// Update the accept handlers list and call the right ones
|
||
var errCanWait = null;
|
||
var updatedNames = new StrSet(acceptedUpdates);
|
||
var oldUpdateHandlers = localHmr.updateHandlers;
|
||
var relevantUpdateHandlers = [];
|
||
var newUpdateHandlers = [];
|
||
for (i=0, len=oldUpdateHandlers.length; i<len; i++) {
|
||
if (!updatedNames.has(oldUpdateHandlers[i].accepter)) {
|
||
newUpdateHandlers.push(oldUpdateHandlers[i]);
|
||
}
|
||
if (updatedNames.hasIntersection(oldUpdateHandlers[i].deps)) {
|
||
relevantUpdateHandlers.push(oldUpdateHandlers[i]);
|
||
}
|
||
}
|
||
localHmr.updateHandlers = newUpdateHandlers;
|
||
for (i=0, len=relevantUpdateHandlers.length; i<len; i++) {
|
||
try {
|
||
relevantUpdateHandlers[i].cb.call(null, acceptedUpdates);
|
||
} catch(e) {
|
||
if (errCanWait) emitError(errCanWait);
|
||
errCanWait = e;
|
||
}
|
||
}
|
||
|
||
// Call the self-accepting modules
|
||
forEach(selfAccepters, function(obj) {
|
||
try {
|
||
require(runtimeModuleInfo[obj.name].index);
|
||
} catch(e) {
|
||
if (obj.cb) {
|
||
obj.cb.call(null, e);
|
||
} else {
|
||
if (errCanWait) emitError(errCanWait);
|
||
errCanWait = e;
|
||
}
|
||
}
|
||
});
|
||
|
||
localHmr.setStatus('idle');
|
||
cb(errCanWait, acceptedUpdates);
|
||
};
|
||
|
||
var moduleHotSetUpdateMode = function(mode, options) {
|
||
options = options || {};
|
||
|
||
if (supportModes.indexOf(mode) === -1) {
|
||
throw new Error("Mode "+mode+" not in supportModes. Please check the Browserify-HMR plugin options.");
|
||
}
|
||
if (mode === 'ajax' && !options.url) {
|
||
throw new Error("url required for ajax update mode");
|
||
}
|
||
if (localHmr.status !== 'idle') {
|
||
throw new Error("module.hot.setUpdateMode can only be called while status is idle");
|
||
}
|
||
|
||
localHmr.newLoad = null;
|
||
localHmr.updateMode = updateMode = mode;
|
||
localHmr.updateUrl = updateUrl = options.url;
|
||
updateCacheBust = options.cacheBust;
|
||
ignoreUnaccepted = has(options, 'ignoreUnaccepted') ? options.ignoreUnaccepted : true;
|
||
|
||
if (socket) {
|
||
socket.disconnect();
|
||
socket = null;
|
||
}
|
||
if (mode === 'websocket') {
|
||
socket = setupSocket();
|
||
}
|
||
};
|
||
|
||
var setupSocket = function() {
|
||
var url = updateUrl || 'http://localhost:3123';
|
||
var socket = socketio(url, {'force new connection': true});
|
||
console.log('[HMR] Attempting websocket connection to', url);
|
||
|
||
var isAcceptingMessages = false;
|
||
socket.on('connect', function() {
|
||
isAcceptingMessages = false;
|
||
var syncMsg = mapValues(runtimeModuleInfo, function(value, name) {
|
||
return {
|
||
hash: value.hash
|
||
};
|
||
});
|
||
socket.emit('sync', syncMsg);
|
||
});
|
||
var isUpdating = false;
|
||
var queuedUpdateMessages = [];
|
||
socket.on('sync confirm', function() {
|
||
console.log('[HMR] Websocket connection successful.');
|
||
isAcceptingMessages = true;
|
||
queuedUpdateMessages = [];
|
||
});
|
||
socket.on('disconnect', function() {
|
||
console.log('[HMR] Websocket connection lost.');
|
||
});
|
||
var acceptNewModules = function(msg) {
|
||
// Make sure we don't accept new modules before we've synced ourselves.
|
||
if (!isAcceptingMessages) return;
|
||
if (isUpdating) {
|
||
queuedUpdateMessages.push(msg);
|
||
return;
|
||
}
|
||
// Take the message and create a localHmr.newLoad value as if the
|
||
// bundle had been re-executed, then call moduleHotApply.
|
||
isUpdating = true;
|
||
|
||
// random id so we can make the normally unnamed args have random names
|
||
var rid = String(Math.random()).replace(/[^0-9]/g, '');
|
||
|
||
var newModuleDefs = localHmr.newLoad ? localHmr.newLoad.moduleDefs : assign({}, moduleDefs);
|
||
var newModuleMeta = localHmr.newLoad ?
|
||
localHmr.newLoad.moduleMeta : mapValues(runtimeModuleInfo, function(value, key) {
|
||
return {
|
||
index: value.index,
|
||
hash: value.hash,
|
||
parents: value.parents.toArray()
|
||
};
|
||
});
|
||
forOwn(msg.newModuleData, function(value, key) {
|
||
newModuleMeta[key] = {
|
||
index: value.index,
|
||
hash: value.hash,
|
||
parents: value.parents
|
||
};
|
||
});
|
||
forEach(msg.removedModules, function(removedName) {
|
||
delete newModuleDefs[runtimeModuleInfo[removedName].index];
|
||
delete newModuleMeta[removedName];
|
||
});
|
||
var newModuleIndexesToNames = makeModuleIndexesToNames(newModuleMeta);
|
||
forOwn(msg.newModuleData, function(value, key) {
|
||
// this part needs to run after newModuleMeta and
|
||
// newModuleIndexesToNames are populated.
|
||
var newModuleFunction = (function() {
|
||
var fn;
|
||
//jshint evil:true
|
||
if (bundle__filename || bundle__dirname) {
|
||
fn = new Function('require', 'module', 'exports', '_u1'+rid, '_u2'+rid, '__u3'+rid, '__u4'+rid, '__filename', '__dirname', value.source);
|
||
return function(require, module, exports, _u1, _u2, _u3, _u4) {
|
||
global._hmr[bundleKey].initModule(key, module);
|
||
fn.call(this, require, module, exports, _u1, _u2, _u3, _u4, bundle__filename, bundle__dirname);
|
||
};
|
||
} else {
|
||
fn = new Function('require', 'module', 'exports', '_u1'+rid, '_u2'+rid, '__u3'+rid, '__u4'+rid, value.source);
|
||
return function(require, module, exports, _u1, _u2, _u3, _u4) {
|
||
global._hmr[bundleKey].initModule(key, module);
|
||
fn.call(this, require, module, exports, _u1, _u2, _u3, _u4);
|
||
};
|
||
}
|
||
})();
|
||
|
||
newModuleDefs[newModuleMeta[key].index] = [
|
||
// module function
|
||
newModuleFunction,
|
||
// module deps
|
||
mapValues(value.deps, function(depIndex, depRef) {
|
||
var depName = newModuleIndexesToNames[depIndex];
|
||
if (has(newModuleMeta, depName)) {
|
||
return newModuleMeta[depName].index;
|
||
} else {
|
||
return depName;
|
||
}
|
||
})
|
||
];
|
||
});
|
||
localHmr.newLoad = {
|
||
moduleDefs: newModuleDefs,
|
||
moduleMeta: newModuleMeta,
|
||
moduleIndexesToNames: newModuleIndexesToNames
|
||
};
|
||
localHmr.setStatus('ready');
|
||
var outdatedModules = getOutdatedModules();
|
||
moduleHotApply({ignoreUnaccepted: ignoreUnaccepted}, function(err, updatedNames) {
|
||
if (err) {
|
||
console.error('[HMR] Error applying update', err);
|
||
}
|
||
if (updatedNames) {
|
||
console.log('[HMR] Updated modules', updatedNames);
|
||
if (outdatedModules.length !== updatedNames.length) {
|
||
var notUpdatedNames = filter(outdatedModules, function(name) {
|
||
return updatedNames.indexOf(name) === -1;
|
||
});
|
||
console.log('[HMR] Some modules were not updated', notUpdatedNames);
|
||
}
|
||
}
|
||
isUpdating = false;
|
||
var queuedMsg;
|
||
while ((queuedMsg = queuedUpdateMessages.shift())) {
|
||
acceptNewModules(queuedMsg);
|
||
}
|
||
});
|
||
};
|
||
socket.on('new modules', acceptNewModules);
|
||
return socket;
|
||
};
|
||
|
||
var localHmr = {
|
||
updateUrl: updateUrl,
|
||
updateMode: updateMode,
|
||
runtimeModuleInfo: runtimeModuleInfo,
|
||
|
||
status: "idle",
|
||
setStatus: function(status) {
|
||
this.status = status;
|
||
var statusHandlers = this.statusHandlers.slice();
|
||
for (var i=0, len=statusHandlers.length; i<len; i++) {
|
||
statusHandlers[i].call(null, status);
|
||
}
|
||
},
|
||
statusHandlers: [],
|
||
updateHandlers: [],
|
||
|
||
// during a reload this is set to an object with moduleDefs,
|
||
// moduleMeta, and moduleIndexesToNames properties
|
||
newLoad: null,
|
||
|
||
initModule: function(name, module) {
|
||
runtimeModuleInfo[name].module = module;
|
||
module.hot = {
|
||
accept: function(deps, cb) {
|
||
if (!cb && (!deps || typeof deps === 'function')) { // self
|
||
cb = deps;
|
||
deps = null;
|
||
runtimeModuleInfo[name].selfAcceptCbs.push(cb);
|
||
} else {
|
||
if (typeof deps === 'string') {
|
||
deps = [deps];
|
||
}
|
||
var depNames = new StrSet();
|
||
for (var i=0, depsLen=deps.length; i<depsLen; i++) {
|
||
var depIndex = moduleDefs[runtimeModuleInfo[name].index][1][deps[i]];
|
||
if (depIndex === undefined || !has(moduleIndexesToNames, depIndex)) {
|
||
throw new Error("File does not use dependency: "+deps[i]);
|
||
}
|
||
depNames.add(moduleIndexesToNames[depIndex]);
|
||
}
|
||
deps = null;
|
||
depNames.forEach(function(depName) {
|
||
runtimeModuleInfo[depName].accepters.add(name);
|
||
runtimeModuleInfo[name].accepting.add(depName);
|
||
});
|
||
if (cb) {
|
||
localHmr.updateHandlers.push({
|
||
accepter: name,
|
||
deps: depNames,
|
||
cb: cb
|
||
});
|
||
}
|
||
}
|
||
},
|
||
decline: function(deps) {
|
||
if (!deps) { // self
|
||
runtimeModuleInfo[name].decliners.add(name);
|
||
runtimeModuleInfo[name].declining.add(name);
|
||
} else {
|
||
if (typeof deps === 'string') {
|
||
deps = [deps];
|
||
}
|
||
for (var i=0, depsLen=deps.length; i<depsLen; i++) {
|
||
var depIndex = moduleDefs[runtimeModuleInfo[name].index][1][deps[i]];
|
||
if (depIndex === undefined || !has(moduleIndexesToNames, depIndex)) {
|
||
throw new Error("File does not use dependency: "+deps[i]);
|
||
}
|
||
var depName = moduleIndexesToNames[depIndex];
|
||
runtimeModuleInfo[depName].decliners.add(name);
|
||
runtimeModuleInfo[name].declining.add(depName);
|
||
}
|
||
}
|
||
},
|
||
data: runtimeModuleInfo[name].disposeData,
|
||
dispose: function(cb) {
|
||
return this.addDisposeHandler(cb);
|
||
},
|
||
addDisposeHandler: function(cb) {
|
||
runtimeModuleInfo[name].disposeHandlers.push(cb);
|
||
},
|
||
removeDisposeHandler: function(cb) {
|
||
var ix = runtimeModuleInfo[name].disposeHandlers.indexOf(cb);
|
||
if (ix !== -1) {
|
||
runtimeModuleInfo[name].disposeHandlers.splice(ix, 1);
|
||
}
|
||
},
|
||
|
||
// Management
|
||
check: moduleHotCheck,
|
||
apply: moduleHotApply,
|
||
status: function(cb) {
|
||
if (cb) {
|
||
return this.addStatusHandler(cb);
|
||
}
|
||
return localHmr.status;
|
||
},
|
||
addStatusHandler: function(cb) {
|
||
localHmr.statusHandlers.push(cb);
|
||
},
|
||
removeStatusHandler: function(cb) {
|
||
var ix = localHmr.statusHandlers.indexOf(cb);
|
||
if (ix !== -1) {
|
||
localHmr.statusHandlers.splice(ix, 1);
|
||
}
|
||
},
|
||
setUpdateMode: moduleHotSetUpdateMode
|
||
};
|
||
}
|
||
};
|
||
global._hmr[bundleKey] = localHmr;
|
||
|
||
if (updateMode === 'websocket') {
|
||
socket = setupSocket();
|
||
}
|
||
return true;
|
||
} else { // We're in a reload!
|
||
global._hmr[bundleKey].newLoad = {
|
||
moduleDefs: moduleDefs,
|
||
moduleMeta: moduleMeta,
|
||
moduleIndexesToNames: moduleIndexesToNames
|
||
};
|
||
return false;
|
||
}
|
||
}
|
||
|
||
module.exports = main;
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../lib/has":11,"../lib/str-set":12,"lodash/array/zipObject":66,"lodash/collection/filter":67,"lodash/collection/forEach":68,"lodash/collection/map":69,"lodash/collection/some":70,"lodash/object/assign":125,"lodash/object/forOwn":126,"lodash/object/mapValues":129}],11:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/browserify-hmr/lib/has.js", module);
|
||
(function(){
|
||
'use strict';
|
||
|
||
function has(object, propName) {
|
||
return Object.prototype.hasOwnProperty.call(object, propName);
|
||
}
|
||
module.exports = has;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],12:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/browserify-hmr/lib/str-set.js", module);
|
||
(function(){
|
||
'use strict';
|
||
|
||
var has = require('./has');
|
||
|
||
function StrSet(other) {
|
||
this._map = {};
|
||
this._size = 0;
|
||
if (other) {
|
||
for (var i=0,len=other.length; i<len; i++) {
|
||
this.add(other[i]);
|
||
}
|
||
}
|
||
}
|
||
StrSet.prototype.add = function(value) {
|
||
if (!this.has(value)) {
|
||
this._map[value] = true;
|
||
this._size++;
|
||
}
|
||
};
|
||
StrSet.prototype.has = function(value) {
|
||
return has(this._map, value);
|
||
};
|
||
StrSet.prototype.del = function(value) {
|
||
if (this.has(value)) {
|
||
delete this._map[value];
|
||
this._size--;
|
||
}
|
||
};
|
||
StrSet.prototype.size = function() {
|
||
return this._size;
|
||
};
|
||
StrSet.prototype.forEach = function(cb) {
|
||
for (var value in this._map) {
|
||
if (has(this._map, value)) {
|
||
cb(value);
|
||
}
|
||
}
|
||
};
|
||
StrSet.prototype.some = function(cb) {
|
||
for (var value in this._map) {
|
||
if (has(this._map, value)) {
|
||
if (cb(value)) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
};
|
||
StrSet.prototype.every = function(cb) {
|
||
return !this.some(function(x) {
|
||
return !cb(x);
|
||
});
|
||
};
|
||
StrSet.prototype.hasIntersection = function(otherStrSet) {
|
||
var value;
|
||
if (this._size < otherStrSet._size) {
|
||
return this.some(function(value) {
|
||
return otherStrSet.has(value);
|
||
});
|
||
} else {
|
||
var self = this;
|
||
return otherStrSet.some(function(value) {
|
||
return self.has(value);
|
||
});
|
||
}
|
||
};
|
||
StrSet.prototype.toArray = function() {
|
||
var arr = [];
|
||
this.forEach(function(value) {
|
||
arr.push(value);
|
||
});
|
||
return arr;
|
||
};
|
||
|
||
module.exports = StrSet;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./has":11}],13:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/component-bind/index.js", module);
|
||
(function(){
|
||
/**
|
||
* Slice reference.
|
||
*/
|
||
|
||
var slice = [].slice;
|
||
|
||
/**
|
||
* Bind `obj` to `fn`.
|
||
*
|
||
* @param {Object} obj
|
||
* @param {Function|String} fn or string
|
||
* @return {Function}
|
||
* @api public
|
||
*/
|
||
|
||
module.exports = function(obj, fn){
|
||
if ('string' == typeof fn) fn = obj[fn];
|
||
if ('function' != typeof fn) throw new Error('bind() requires a function');
|
||
var args = slice.call(arguments, 2);
|
||
return function(){
|
||
return fn.apply(obj, args.concat(slice.call(arguments)));
|
||
}
|
||
};
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],14:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/component-emitter/index.js", module);
|
||
(function(){
|
||
|
||
/**
|
||
* Expose `Emitter`.
|
||
*/
|
||
|
||
module.exports = Emitter;
|
||
|
||
/**
|
||
* Initialize a new `Emitter`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
function Emitter(obj) {
|
||
if (obj) return mixin(obj);
|
||
};
|
||
|
||
/**
|
||
* Mixin the emitter properties.
|
||
*
|
||
* @param {Object} obj
|
||
* @return {Object}
|
||
* @api private
|
||
*/
|
||
|
||
function mixin(obj) {
|
||
for (var key in Emitter.prototype) {
|
||
obj[key] = Emitter.prototype[key];
|
||
}
|
||
return obj;
|
||
}
|
||
|
||
/**
|
||
* Listen on the given `event` with `fn`.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
* @return {Emitter}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.on =
|
||
Emitter.prototype.addEventListener = function(event, fn){
|
||
this._callbacks = this._callbacks || {};
|
||
(this._callbacks[event] = this._callbacks[event] || [])
|
||
.push(fn);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Adds an `event` listener that will be invoked a single
|
||
* time then automatically removed.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
* @return {Emitter}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.once = function(event, fn){
|
||
var self = this;
|
||
this._callbacks = this._callbacks || {};
|
||
|
||
function on() {
|
||
self.off(event, on);
|
||
fn.apply(this, arguments);
|
||
}
|
||
|
||
on.fn = fn;
|
||
this.on(event, on);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Remove the given callback for `event` or all
|
||
* registered callbacks.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
* @return {Emitter}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.off =
|
||
Emitter.prototype.removeListener =
|
||
Emitter.prototype.removeAllListeners =
|
||
Emitter.prototype.removeEventListener = function(event, fn){
|
||
this._callbacks = this._callbacks || {};
|
||
|
||
// all
|
||
if (0 == arguments.length) {
|
||
this._callbacks = {};
|
||
return this;
|
||
}
|
||
|
||
// specific event
|
||
var callbacks = this._callbacks[event];
|
||
if (!callbacks) return this;
|
||
|
||
// remove all handlers
|
||
if (1 == arguments.length) {
|
||
delete this._callbacks[event];
|
||
return this;
|
||
}
|
||
|
||
// remove specific handler
|
||
var cb;
|
||
for (var i = 0; i < callbacks.length; i++) {
|
||
cb = callbacks[i];
|
||
if (cb === fn || cb.fn === fn) {
|
||
callbacks.splice(i, 1);
|
||
break;
|
||
}
|
||
}
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Emit `event` with the given args.
|
||
*
|
||
* @param {String} event
|
||
* @param {Mixed} ...
|
||
* @return {Emitter}
|
||
*/
|
||
|
||
Emitter.prototype.emit = function(event){
|
||
this._callbacks = this._callbacks || {};
|
||
var args = [].slice.call(arguments, 1)
|
||
, callbacks = this._callbacks[event];
|
||
|
||
if (callbacks) {
|
||
callbacks = callbacks.slice(0);
|
||
for (var i = 0, len = callbacks.length; i < len; ++i) {
|
||
callbacks[i].apply(this, args);
|
||
}
|
||
}
|
||
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Return array of callbacks for `event`.
|
||
*
|
||
* @param {String} event
|
||
* @return {Array}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.listeners = function(event){
|
||
this._callbacks = this._callbacks || {};
|
||
return this._callbacks[event] || [];
|
||
};
|
||
|
||
/**
|
||
* Check if this emitter has `event` handlers.
|
||
*
|
||
* @param {String} event
|
||
* @return {Boolean}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.hasListeners = function(event){
|
||
return !! this.listeners(event).length;
|
||
};
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],15:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/component-inherit/index.js", module);
|
||
(function(){
|
||
|
||
module.exports = function(a, b){
|
||
var fn = function(){};
|
||
fn.prototype = b.prototype;
|
||
a.prototype = new fn;
|
||
a.prototype.constructor = a;
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{}],16:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/fn/symbol/index.js", module);
|
||
(function(){
|
||
require('../../modules/es6.symbol');
|
||
require('../../modules/es6.object.to-string');
|
||
module.exports = require('../../modules/$.core').Symbol;
|
||
}).apply(this, arguments);
|
||
|
||
},{"../../modules/$.core":20,"../../modules/es6.object.to-string":44,"../../modules/es6.symbol":45}],17:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.a-function.js", module);
|
||
(function(){
|
||
module.exports = function(it){
|
||
if(typeof it != 'function')throw TypeError(it + ' is not a function!');
|
||
return it;
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{}],18:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.an-object.js", module);
|
||
(function(){
|
||
var isObject = require('./$.is-object');
|
||
module.exports = function(it){
|
||
if(!isObject(it))throw TypeError(it + ' is not an object!');
|
||
return it;
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$.is-object":33}],19:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.cof.js", module);
|
||
(function(){
|
||
var toString = {}.toString;
|
||
|
||
module.exports = function(it){
|
||
return toString.call(it).slice(8, -1);
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{}],20:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.core.js", module);
|
||
(function(){
|
||
var core = module.exports = {version: '1.2.6'};
|
||
if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
|
||
}).apply(this, arguments);
|
||
|
||
},{}],21:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.ctx.js", module);
|
||
(function(){
|
||
// optional / simple context binding
|
||
var aFunction = require('./$.a-function');
|
||
module.exports = function(fn, that, length){
|
||
aFunction(fn);
|
||
if(that === undefined)return fn;
|
||
switch(length){
|
||
case 1: return function(a){
|
||
return fn.call(that, a);
|
||
};
|
||
case 2: return function(a, b){
|
||
return fn.call(that, a, b);
|
||
};
|
||
case 3: return function(a, b, c){
|
||
return fn.call(that, a, b, c);
|
||
};
|
||
}
|
||
return function(/* ...args */){
|
||
return fn.apply(that, arguments);
|
||
};
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$.a-function":17}],22:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.defined.js", module);
|
||
(function(){
|
||
// 7.2.1 RequireObjectCoercible(argument)
|
||
module.exports = function(it){
|
||
if(it == undefined)throw TypeError("Can't call method on " + it);
|
||
return it;
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{}],23:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.descriptors.js", module);
|
||
(function(){
|
||
// Thank's IE8 for his funny defineProperty
|
||
module.exports = !require('./$.fails')(function(){
|
||
return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
|
||
});
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$.fails":26}],24:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.enum-keys.js", module);
|
||
(function(){
|
||
// all enumerable object keys, includes symbols
|
||
var $ = require('./$');
|
||
module.exports = function(it){
|
||
var keys = $.getKeys(it)
|
||
, getSymbols = $.getSymbols;
|
||
if(getSymbols){
|
||
var symbols = getSymbols(it)
|
||
, isEnum = $.isEnum
|
||
, i = 0
|
||
, key;
|
||
while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))keys.push(key);
|
||
}
|
||
return keys;
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$":34}],25:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.export.js", module);
|
||
(function(){
|
||
var global = require('./$.global')
|
||
, core = require('./$.core')
|
||
, ctx = require('./$.ctx')
|
||
, PROTOTYPE = 'prototype';
|
||
|
||
var $export = function(type, name, source){
|
||
var IS_FORCED = type & $export.F
|
||
, IS_GLOBAL = type & $export.G
|
||
, IS_STATIC = type & $export.S
|
||
, IS_PROTO = type & $export.P
|
||
, IS_BIND = type & $export.B
|
||
, IS_WRAP = type & $export.W
|
||
, exports = IS_GLOBAL ? core : core[name] || (core[name] = {})
|
||
, target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]
|
||
, key, own, out;
|
||
if(IS_GLOBAL)source = name;
|
||
for(key in source){
|
||
// contains in native
|
||
own = !IS_FORCED && target && key in target;
|
||
if(own && key in exports)continue;
|
||
// export native or passed
|
||
out = own ? target[key] : source[key];
|
||
// prevent global pollution for namespaces
|
||
exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
|
||
// bind timers to global for call from export context
|
||
: IS_BIND && own ? ctx(out, global)
|
||
// wrap global constructors for prevent change them in library
|
||
: IS_WRAP && target[key] == out ? (function(C){
|
||
var F = function(param){
|
||
return this instanceof C ? new C(param) : C(param);
|
||
};
|
||
F[PROTOTYPE] = C[PROTOTYPE];
|
||
return F;
|
||
// make static versions for prototype methods
|
||
})(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
|
||
if(IS_PROTO)(exports[PROTOTYPE] || (exports[PROTOTYPE] = {}))[key] = out;
|
||
}
|
||
};
|
||
// type bitmap
|
||
$export.F = 1; // forced
|
||
$export.G = 2; // global
|
||
$export.S = 4; // static
|
||
$export.P = 8; // proto
|
||
$export.B = 16; // bind
|
||
$export.W = 32; // wrap
|
||
module.exports = $export;
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$.core":20,"./$.ctx":21,"./$.global":28}],26:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.fails.js", module);
|
||
(function(){
|
||
module.exports = function(exec){
|
||
try {
|
||
return !!exec();
|
||
} catch(e){
|
||
return true;
|
||
}
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{}],27:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.get-names.js", module);
|
||
(function(){
|
||
// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
|
||
var toIObject = require('./$.to-iobject')
|
||
, getNames = require('./$').getNames
|
||
, toString = {}.toString;
|
||
|
||
var windowNames = typeof window == 'object' && Object.getOwnPropertyNames
|
||
? Object.getOwnPropertyNames(window) : [];
|
||
|
||
var getWindowNames = function(it){
|
||
try {
|
||
return getNames(it);
|
||
} catch(e){
|
||
return windowNames.slice();
|
||
}
|
||
};
|
||
|
||
module.exports.get = function getOwnPropertyNames(it){
|
||
if(windowNames && toString.call(it) == '[object Window]')return getWindowNames(it);
|
||
return getNames(toIObject(it));
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$":34,"./$.to-iobject":41}],28:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.global.js", module);
|
||
(function(){
|
||
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
|
||
var global = module.exports = typeof window != 'undefined' && window.Math == Math
|
||
? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
|
||
if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
|
||
}).apply(this, arguments);
|
||
|
||
},{}],29:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.has.js", module);
|
||
(function(){
|
||
var hasOwnProperty = {}.hasOwnProperty;
|
||
module.exports = function(it, key){
|
||
return hasOwnProperty.call(it, key);
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{}],30:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.hide.js", module);
|
||
(function(){
|
||
var $ = require('./$')
|
||
, createDesc = require('./$.property-desc');
|
||
module.exports = require('./$.descriptors') ? function(object, key, value){
|
||
return $.setDesc(object, key, createDesc(1, value));
|
||
} : function(object, key, value){
|
||
object[key] = value;
|
||
return object;
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$":34,"./$.descriptors":23,"./$.property-desc":37}],31:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.iobject.js", module);
|
||
(function(){
|
||
// fallback for non-array-like ES3 and non-enumerable old V8 strings
|
||
var cof = require('./$.cof');
|
||
module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
|
||
return cof(it) == 'String' ? it.split('') : Object(it);
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$.cof":19}],32:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.is-array.js", module);
|
||
(function(){
|
||
// 7.2.2 IsArray(argument)
|
||
var cof = require('./$.cof');
|
||
module.exports = Array.isArray || function(arg){
|
||
return cof(arg) == 'Array';
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$.cof":19}],33:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.is-object.js", module);
|
||
(function(){
|
||
module.exports = function(it){
|
||
return typeof it === 'object' ? it !== null : typeof it === 'function';
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{}],34:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.js", module);
|
||
(function(){
|
||
var $Object = Object;
|
||
module.exports = {
|
||
create: $Object.create,
|
||
getProto: $Object.getPrototypeOf,
|
||
isEnum: {}.propertyIsEnumerable,
|
||
getDesc: $Object.getOwnPropertyDescriptor,
|
||
setDesc: $Object.defineProperty,
|
||
setDescs: $Object.defineProperties,
|
||
getKeys: $Object.keys,
|
||
getNames: $Object.getOwnPropertyNames,
|
||
getSymbols: $Object.getOwnPropertySymbols,
|
||
each: [].forEach
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{}],35:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.keyof.js", module);
|
||
(function(){
|
||
var $ = require('./$')
|
||
, toIObject = require('./$.to-iobject');
|
||
module.exports = function(object, el){
|
||
var O = toIObject(object)
|
||
, keys = $.getKeys(O)
|
||
, length = keys.length
|
||
, index = 0
|
||
, key;
|
||
while(length > index)if(O[key = keys[index++]] === el)return key;
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$":34,"./$.to-iobject":41}],36:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.library.js", module);
|
||
(function(){
|
||
module.exports = true;
|
||
}).apply(this, arguments);
|
||
|
||
},{}],37:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.property-desc.js", module);
|
||
(function(){
|
||
module.exports = function(bitmap, value){
|
||
return {
|
||
enumerable : !(bitmap & 1),
|
||
configurable: !(bitmap & 2),
|
||
writable : !(bitmap & 4),
|
||
value : value
|
||
};
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{}],38:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.redefine.js", module);
|
||
(function(){
|
||
module.exports = require('./$.hide');
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$.hide":30}],39:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.set-to-string-tag.js", module);
|
||
(function(){
|
||
var def = require('./$').setDesc
|
||
, has = require('./$.has')
|
||
, TAG = require('./$.wks')('toStringTag');
|
||
|
||
module.exports = function(it, tag, stat){
|
||
if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$":34,"./$.has":29,"./$.wks":43}],40:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.shared.js", module);
|
||
(function(){
|
||
var global = require('./$.global')
|
||
, SHARED = '__core-js_shared__'
|
||
, store = global[SHARED] || (global[SHARED] = {});
|
||
module.exports = function(key){
|
||
return store[key] || (store[key] = {});
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$.global":28}],41:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.to-iobject.js", module);
|
||
(function(){
|
||
// to indexed object, toObject with fallback for non-array-like ES3 strings
|
||
var IObject = require('./$.iobject')
|
||
, defined = require('./$.defined');
|
||
module.exports = function(it){
|
||
return IObject(defined(it));
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$.defined":22,"./$.iobject":31}],42:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.uid.js", module);
|
||
(function(){
|
||
var id = 0
|
||
, px = Math.random();
|
||
module.exports = function(key){
|
||
return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{}],43:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/$.wks.js", module);
|
||
(function(){
|
||
var store = require('./$.shared')('wks')
|
||
, uid = require('./$.uid')
|
||
, Symbol = require('./$.global').Symbol;
|
||
module.exports = function(name){
|
||
return store[name] || (store[name] =
|
||
Symbol && Symbol[name] || (Symbol || uid)('Symbol.' + name));
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$.global":28,"./$.shared":40,"./$.uid":42}],44:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/es6.object.to-string.js", module);
|
||
(function(){
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],45:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/core-js/library/modules/es6.symbol.js", module);
|
||
(function(){
|
||
'use strict';
|
||
// ECMAScript 6 symbols shim
|
||
var $ = require('./$')
|
||
, global = require('./$.global')
|
||
, has = require('./$.has')
|
||
, DESCRIPTORS = require('./$.descriptors')
|
||
, $export = require('./$.export')
|
||
, redefine = require('./$.redefine')
|
||
, $fails = require('./$.fails')
|
||
, shared = require('./$.shared')
|
||
, setToStringTag = require('./$.set-to-string-tag')
|
||
, uid = require('./$.uid')
|
||
, wks = require('./$.wks')
|
||
, keyOf = require('./$.keyof')
|
||
, $names = require('./$.get-names')
|
||
, enumKeys = require('./$.enum-keys')
|
||
, isArray = require('./$.is-array')
|
||
, anObject = require('./$.an-object')
|
||
, toIObject = require('./$.to-iobject')
|
||
, createDesc = require('./$.property-desc')
|
||
, getDesc = $.getDesc
|
||
, setDesc = $.setDesc
|
||
, _create = $.create
|
||
, getNames = $names.get
|
||
, $Symbol = global.Symbol
|
||
, $JSON = global.JSON
|
||
, _stringify = $JSON && $JSON.stringify
|
||
, setter = false
|
||
, HIDDEN = wks('_hidden')
|
||
, isEnum = $.isEnum
|
||
, SymbolRegistry = shared('symbol-registry')
|
||
, AllSymbols = shared('symbols')
|
||
, useNative = typeof $Symbol == 'function'
|
||
, ObjectProto = Object.prototype;
|
||
|
||
// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
|
||
var setSymbolDesc = DESCRIPTORS && $fails(function(){
|
||
return _create(setDesc({}, 'a', {
|
||
get: function(){ return setDesc(this, 'a', {value: 7}).a; }
|
||
})).a != 7;
|
||
}) ? function(it, key, D){
|
||
var protoDesc = getDesc(ObjectProto, key);
|
||
if(protoDesc)delete ObjectProto[key];
|
||
setDesc(it, key, D);
|
||
if(protoDesc && it !== ObjectProto)setDesc(ObjectProto, key, protoDesc);
|
||
} : setDesc;
|
||
|
||
var wrap = function(tag){
|
||
var sym = AllSymbols[tag] = _create($Symbol.prototype);
|
||
sym._k = tag;
|
||
DESCRIPTORS && setter && setSymbolDesc(ObjectProto, tag, {
|
||
configurable: true,
|
||
set: function(value){
|
||
if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;
|
||
setSymbolDesc(this, tag, createDesc(1, value));
|
||
}
|
||
});
|
||
return sym;
|
||
};
|
||
|
||
var isSymbol = function(it){
|
||
return typeof it == 'symbol';
|
||
};
|
||
|
||
var $defineProperty = function defineProperty(it, key, D){
|
||
if(D && has(AllSymbols, key)){
|
||
if(!D.enumerable){
|
||
if(!has(it, HIDDEN))setDesc(it, HIDDEN, createDesc(1, {}));
|
||
it[HIDDEN][key] = true;
|
||
} else {
|
||
if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;
|
||
D = _create(D, {enumerable: createDesc(0, false)});
|
||
} return setSymbolDesc(it, key, D);
|
||
} return setDesc(it, key, D);
|
||
};
|
||
var $defineProperties = function defineProperties(it, P){
|
||
anObject(it);
|
||
var keys = enumKeys(P = toIObject(P))
|
||
, i = 0
|
||
, l = keys.length
|
||
, key;
|
||
while(l > i)$defineProperty(it, key = keys[i++], P[key]);
|
||
return it;
|
||
};
|
||
var $create = function create(it, P){
|
||
return P === undefined ? _create(it) : $defineProperties(_create(it), P);
|
||
};
|
||
var $propertyIsEnumerable = function propertyIsEnumerable(key){
|
||
var E = isEnum.call(this, key);
|
||
return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key]
|
||
? E : true;
|
||
};
|
||
var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){
|
||
var D = getDesc(it = toIObject(it), key);
|
||
if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;
|
||
return D;
|
||
};
|
||
var $getOwnPropertyNames = function getOwnPropertyNames(it){
|
||
var names = getNames(toIObject(it))
|
||
, result = []
|
||
, i = 0
|
||
, key;
|
||
while(names.length > i)if(!has(AllSymbols, key = names[i++]) && key != HIDDEN)result.push(key);
|
||
return result;
|
||
};
|
||
var $getOwnPropertySymbols = function getOwnPropertySymbols(it){
|
||
var names = getNames(toIObject(it))
|
||
, result = []
|
||
, i = 0
|
||
, key;
|
||
while(names.length > i)if(has(AllSymbols, key = names[i++]))result.push(AllSymbols[key]);
|
||
return result;
|
||
};
|
||
var $stringify = function stringify(it){
|
||
if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined
|
||
var args = [it]
|
||
, i = 1
|
||
, $$ = arguments
|
||
, replacer, $replacer;
|
||
while($$.length > i)args.push($$[i++]);
|
||
replacer = args[1];
|
||
if(typeof replacer == 'function')$replacer = replacer;
|
||
if($replacer || !isArray(replacer))replacer = function(key, value){
|
||
if($replacer)value = $replacer.call(this, key, value);
|
||
if(!isSymbol(value))return value;
|
||
};
|
||
args[1] = replacer;
|
||
return _stringify.apply($JSON, args);
|
||
};
|
||
var buggyJSON = $fails(function(){
|
||
var S = $Symbol();
|
||
// MS Edge converts symbol values to JSON as {}
|
||
// WebKit converts symbol values to JSON as null
|
||
// V8 throws on boxed symbols
|
||
return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}';
|
||
});
|
||
|
||
// 19.4.1.1 Symbol([description])
|
||
if(!useNative){
|
||
$Symbol = function Symbol(){
|
||
if(isSymbol(this))throw TypeError('Symbol is not a constructor');
|
||
return wrap(uid(arguments.length > 0 ? arguments[0] : undefined));
|
||
};
|
||
redefine($Symbol.prototype, 'toString', function toString(){
|
||
return this._k;
|
||
});
|
||
|
||
isSymbol = function(it){
|
||
return it instanceof $Symbol;
|
||
};
|
||
|
||
$.create = $create;
|
||
$.isEnum = $propertyIsEnumerable;
|
||
$.getDesc = $getOwnPropertyDescriptor;
|
||
$.setDesc = $defineProperty;
|
||
$.setDescs = $defineProperties;
|
||
$.getNames = $names.get = $getOwnPropertyNames;
|
||
$.getSymbols = $getOwnPropertySymbols;
|
||
|
||
if(DESCRIPTORS && !require('./$.library')){
|
||
redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
|
||
}
|
||
}
|
||
|
||
var symbolStatics = {
|
||
// 19.4.2.1 Symbol.for(key)
|
||
'for': function(key){
|
||
return has(SymbolRegistry, key += '')
|
||
? SymbolRegistry[key]
|
||
: SymbolRegistry[key] = $Symbol(key);
|
||
},
|
||
// 19.4.2.5 Symbol.keyFor(sym)
|
||
keyFor: function keyFor(key){
|
||
return keyOf(SymbolRegistry, key);
|
||
},
|
||
useSetter: function(){ setter = true; },
|
||
useSimple: function(){ setter = false; }
|
||
};
|
||
// 19.4.2.2 Symbol.hasInstance
|
||
// 19.4.2.3 Symbol.isConcatSpreadable
|
||
// 19.4.2.4 Symbol.iterator
|
||
// 19.4.2.6 Symbol.match
|
||
// 19.4.2.8 Symbol.replace
|
||
// 19.4.2.9 Symbol.search
|
||
// 19.4.2.10 Symbol.species
|
||
// 19.4.2.11 Symbol.split
|
||
// 19.4.2.12 Symbol.toPrimitive
|
||
// 19.4.2.13 Symbol.toStringTag
|
||
// 19.4.2.14 Symbol.unscopables
|
||
$.each.call((
|
||
'hasInstance,isConcatSpreadable,iterator,match,replace,search,' +
|
||
'species,split,toPrimitive,toStringTag,unscopables'
|
||
).split(','), function(it){
|
||
var sym = wks(it);
|
||
symbolStatics[it] = useNative ? sym : wrap(sym);
|
||
});
|
||
|
||
setter = true;
|
||
|
||
$export($export.G + $export.W, {Symbol: $Symbol});
|
||
|
||
$export($export.S, 'Symbol', symbolStatics);
|
||
|
||
$export($export.S + $export.F * !useNative, 'Object', {
|
||
// 19.1.2.2 Object.create(O [, Properties])
|
||
create: $create,
|
||
// 19.1.2.4 Object.defineProperty(O, P, Attributes)
|
||
defineProperty: $defineProperty,
|
||
// 19.1.2.3 Object.defineProperties(O, Properties)
|
||
defineProperties: $defineProperties,
|
||
// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
|
||
getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
|
||
// 19.1.2.7 Object.getOwnPropertyNames(O)
|
||
getOwnPropertyNames: $getOwnPropertyNames,
|
||
// 19.1.2.8 Object.getOwnPropertySymbols(O)
|
||
getOwnPropertySymbols: $getOwnPropertySymbols
|
||
});
|
||
|
||
// 24.3.2 JSON.stringify(value [, replacer [, space]])
|
||
$JSON && $export($export.S + $export.F * (!useNative || buggyJSON), 'JSON', {stringify: $stringify});
|
||
|
||
// 19.4.3.5 Symbol.prototype[@@toStringTag]
|
||
setToStringTag($Symbol, 'Symbol');
|
||
// 20.2.1.9 Math[@@toStringTag]
|
||
setToStringTag(Math, 'Math', true);
|
||
// 24.3.3 JSON[@@toStringTag]
|
||
setToStringTag(global.JSON, 'JSON', true);
|
||
}).apply(this, arguments);
|
||
|
||
},{"./$":34,"./$.an-object":18,"./$.descriptors":23,"./$.enum-keys":24,"./$.export":25,"./$.fails":26,"./$.get-names":27,"./$.global":28,"./$.has":29,"./$.is-array":32,"./$.keyof":35,"./$.library":36,"./$.property-desc":37,"./$.redefine":38,"./$.set-to-string-tag":39,"./$.shared":40,"./$.to-iobject":41,"./$.uid":42,"./$.wks":43}],46:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/debug/browser.js", module);
|
||
(function(){
|
||
|
||
/**
|
||
* This is the web browser implementation of `debug()`.
|
||
*
|
||
* Expose `debug()` as the module.
|
||
*/
|
||
|
||
exports = module.exports = require('./debug');
|
||
exports.log = log;
|
||
exports.formatArgs = formatArgs;
|
||
exports.save = save;
|
||
exports.load = load;
|
||
exports.useColors = useColors;
|
||
exports.storage = 'undefined' != typeof chrome
|
||
&& 'undefined' != typeof chrome.storage
|
||
? chrome.storage.local
|
||
: localstorage();
|
||
|
||
/**
|
||
* Colors.
|
||
*/
|
||
|
||
exports.colors = [
|
||
'lightseagreen',
|
||
'forestgreen',
|
||
'goldenrod',
|
||
'dodgerblue',
|
||
'darkorchid',
|
||
'crimson'
|
||
];
|
||
|
||
/**
|
||
* Currently only WebKit-based Web Inspectors, Firefox >= v31,
|
||
* and the Firebug extension (any Firefox version) are known
|
||
* to support "%c" CSS customizations.
|
||
*
|
||
* TODO: add a `localStorage` variable to explicitly enable/disable colors
|
||
*/
|
||
|
||
function useColors() {
|
||
// is webkit? http://stackoverflow.com/a/16459606/376773
|
||
return ('WebkitAppearance' in document.documentElement.style) ||
|
||
// is firebug? http://stackoverflow.com/a/398120/376773
|
||
(window.console && (console.firebug || (console.exception && console.table))) ||
|
||
// is firefox >= v31?
|
||
// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
|
||
(navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31);
|
||
}
|
||
|
||
/**
|
||
* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
|
||
*/
|
||
|
||
exports.formatters.j = function(v) {
|
||
return JSON.stringify(v);
|
||
};
|
||
|
||
|
||
/**
|
||
* Colorize log arguments if enabled.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
function formatArgs() {
|
||
var args = arguments;
|
||
var useColors = this.useColors;
|
||
|
||
args[0] = (useColors ? '%c' : '')
|
||
+ this.namespace
|
||
+ (useColors ? ' %c' : ' ')
|
||
+ args[0]
|
||
+ (useColors ? '%c ' : ' ')
|
||
+ '+' + exports.humanize(this.diff);
|
||
|
||
if (!useColors) return args;
|
||
|
||
var c = 'color: ' + this.color;
|
||
args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1));
|
||
|
||
// the final "%c" is somewhat tricky, because there could be other
|
||
// arguments passed either before or after the %c, so we need to
|
||
// figure out the correct index to insert the CSS into
|
||
var index = 0;
|
||
var lastC = 0;
|
||
args[0].replace(/%[a-z%]/g, function(match) {
|
||
if ('%%' === match) return;
|
||
index++;
|
||
if ('%c' === match) {
|
||
// we only are interested in the *last* %c
|
||
// (the user may have provided their own)
|
||
lastC = index;
|
||
}
|
||
});
|
||
|
||
args.splice(lastC, 0, c);
|
||
return args;
|
||
}
|
||
|
||
/**
|
||
* Invokes `console.log()` when available.
|
||
* No-op when `console.log` is not a "function".
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
function log() {
|
||
// this hackery is required for IE8/9, where
|
||
// the `console.log` function doesn't have 'apply'
|
||
return 'object' === typeof console
|
||
&& console.log
|
||
&& Function.prototype.apply.call(console.log, console, arguments);
|
||
}
|
||
|
||
/**
|
||
* Save `namespaces`.
|
||
*
|
||
* @param {String} namespaces
|
||
* @api private
|
||
*/
|
||
|
||
function save(namespaces) {
|
||
try {
|
||
if (null == namespaces) {
|
||
exports.storage.removeItem('debug');
|
||
} else {
|
||
exports.storage.debug = namespaces;
|
||
}
|
||
} catch(e) {}
|
||
}
|
||
|
||
/**
|
||
* Load `namespaces`.
|
||
*
|
||
* @return {String} returns the previously persisted debug modes
|
||
* @api private
|
||
*/
|
||
|
||
function load() {
|
||
var r;
|
||
try {
|
||
r = exports.storage.debug;
|
||
} catch(e) {}
|
||
return r;
|
||
}
|
||
|
||
/**
|
||
* Enable namespaces listed in `localStorage.debug` initially.
|
||
*/
|
||
|
||
exports.enable(load());
|
||
|
||
/**
|
||
* Localstorage attempts to return the localstorage.
|
||
*
|
||
* This is necessary because safari throws
|
||
* when a user disables cookies/localstorage
|
||
* and you attempt to access it.
|
||
*
|
||
* @return {LocalStorage}
|
||
* @api private
|
||
*/
|
||
|
||
function localstorage(){
|
||
try {
|
||
return window.localStorage;
|
||
} catch (e) {}
|
||
}
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./debug":47}],47:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/debug/debug.js", module);
|
||
(function(){
|
||
|
||
/**
|
||
* This is the common logic for both the Node.js and web browser
|
||
* implementations of `debug()`.
|
||
*
|
||
* Expose `debug()` as the module.
|
||
*/
|
||
|
||
exports = module.exports = debug;
|
||
exports.coerce = coerce;
|
||
exports.disable = disable;
|
||
exports.enable = enable;
|
||
exports.enabled = enabled;
|
||
exports.humanize = require('ms');
|
||
|
||
/**
|
||
* The currently active debug mode names, and names to skip.
|
||
*/
|
||
|
||
exports.names = [];
|
||
exports.skips = [];
|
||
|
||
/**
|
||
* Map of special "%n" handling functions, for the debug "format" argument.
|
||
*
|
||
* Valid key names are a single, lowercased letter, i.e. "n".
|
||
*/
|
||
|
||
exports.formatters = {};
|
||
|
||
/**
|
||
* Previously assigned color.
|
||
*/
|
||
|
||
var prevColor = 0;
|
||
|
||
/**
|
||
* Previous log timestamp.
|
||
*/
|
||
|
||
var prevTime;
|
||
|
||
/**
|
||
* Select a color.
|
||
*
|
||
* @return {Number}
|
||
* @api private
|
||
*/
|
||
|
||
function selectColor() {
|
||
return exports.colors[prevColor++ % exports.colors.length];
|
||
}
|
||
|
||
/**
|
||
* Create a debugger with the given `namespace`.
|
||
*
|
||
* @param {String} namespace
|
||
* @return {Function}
|
||
* @api public
|
||
*/
|
||
|
||
function debug(namespace) {
|
||
|
||
// define the `disabled` version
|
||
function disabled() {
|
||
}
|
||
disabled.enabled = false;
|
||
|
||
// define the `enabled` version
|
||
function enabled() {
|
||
|
||
var self = enabled;
|
||
|
||
// set `diff` timestamp
|
||
var curr = +new Date();
|
||
var ms = curr - (prevTime || curr);
|
||
self.diff = ms;
|
||
self.prev = prevTime;
|
||
self.curr = curr;
|
||
prevTime = curr;
|
||
|
||
// add the `color` if not set
|
||
if (null == self.useColors) self.useColors = exports.useColors();
|
||
if (null == self.color && self.useColors) self.color = selectColor();
|
||
|
||
var args = Array.prototype.slice.call(arguments);
|
||
|
||
args[0] = exports.coerce(args[0]);
|
||
|
||
if ('string' !== typeof args[0]) {
|
||
// anything else let's inspect with %o
|
||
args = ['%o'].concat(args);
|
||
}
|
||
|
||
// apply any `formatters` transformations
|
||
var index = 0;
|
||
args[0] = args[0].replace(/%([a-z%])/g, function(match, format) {
|
||
// if we encounter an escaped % then don't increase the array index
|
||
if (match === '%%') return match;
|
||
index++;
|
||
var formatter = exports.formatters[format];
|
||
if ('function' === typeof formatter) {
|
||
var val = args[index];
|
||
match = formatter.call(self, val);
|
||
|
||
// now we need to remove `args[index]` since it's inlined in the `format`
|
||
args.splice(index, 1);
|
||
index--;
|
||
}
|
||
return match;
|
||
});
|
||
|
||
if ('function' === typeof exports.formatArgs) {
|
||
args = exports.formatArgs.apply(self, args);
|
||
}
|
||
var logFn = enabled.log || exports.log || console.log.bind(console);
|
||
logFn.apply(self, args);
|
||
}
|
||
enabled.enabled = true;
|
||
|
||
var fn = exports.enabled(namespace) ? enabled : disabled;
|
||
|
||
fn.namespace = namespace;
|
||
|
||
return fn;
|
||
}
|
||
|
||
/**
|
||
* Enables a debug mode by namespaces. This can include modes
|
||
* separated by a colon and wildcards.
|
||
*
|
||
* @param {String} namespaces
|
||
* @api public
|
||
*/
|
||
|
||
function enable(namespaces) {
|
||
exports.save(namespaces);
|
||
|
||
var split = (namespaces || '').split(/[\s,]+/);
|
||
var len = split.length;
|
||
|
||
for (var i = 0; i < len; i++) {
|
||
if (!split[i]) continue; // ignore empty strings
|
||
namespaces = split[i].replace(/\*/g, '.*?');
|
||
if (namespaces[0] === '-') {
|
||
exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
|
||
} else {
|
||
exports.names.push(new RegExp('^' + namespaces + '$'));
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Disable debug output.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
function disable() {
|
||
exports.enable('');
|
||
}
|
||
|
||
/**
|
||
* Returns true if the given mode name is enabled, false otherwise.
|
||
*
|
||
* @param {String} name
|
||
* @return {Boolean}
|
||
* @api public
|
||
*/
|
||
|
||
function enabled(name) {
|
||
var i, len;
|
||
for (i = 0, len = exports.skips.length; i < len; i++) {
|
||
if (exports.skips[i].test(name)) {
|
||
return false;
|
||
}
|
||
}
|
||
for (i = 0, len = exports.names.length; i < len; i++) {
|
||
if (exports.names[i].test(name)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Coerce `val`.
|
||
*
|
||
* @param {Mixed} val
|
||
* @return {Mixed}
|
||
* @api private
|
||
*/
|
||
|
||
function coerce(val) {
|
||
if (val instanceof Error) return val.stack || val.message;
|
||
return val;
|
||
}
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"ms":133}],48:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/engine.io-client/index.js", module);
|
||
(function(){
|
||
|
||
module.exports = require('./lib/');
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./lib/":49}],49:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/engine.io-client/lib/index.js", module);
|
||
(function(){
|
||
|
||
module.exports = require('./socket');
|
||
|
||
/**
|
||
* Exports parser
|
||
*
|
||
* @api public
|
||
*
|
||
*/
|
||
module.exports.parser = require('engine.io-parser');
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./socket":50,"engine.io-parser":58}],50:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/engine.io-client/lib/socket.js", module);
|
||
(function(){
|
||
(function (global){
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var transports = require('./transports');
|
||
var Emitter = require('component-emitter');
|
||
var debug = require('debug')('engine.io-client:socket');
|
||
var index = require('indexof');
|
||
var parser = require('engine.io-parser');
|
||
var parseuri = require('parseuri');
|
||
var parsejson = require('parsejson');
|
||
var parseqs = require('parseqs');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = Socket;
|
||
|
||
/**
|
||
* Noop function.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
function noop(){}
|
||
|
||
/**
|
||
* Socket constructor.
|
||
*
|
||
* @param {String|Object} uri or options
|
||
* @param {Object} options
|
||
* @api public
|
||
*/
|
||
|
||
function Socket(uri, opts){
|
||
if (!(this instanceof Socket)) return new Socket(uri, opts);
|
||
|
||
opts = opts || {};
|
||
|
||
if (uri && 'object' == typeof uri) {
|
||
opts = uri;
|
||
uri = null;
|
||
}
|
||
|
||
if (uri) {
|
||
uri = parseuri(uri);
|
||
opts.hostname = uri.host;
|
||
opts.secure = uri.protocol == 'https' || uri.protocol == 'wss';
|
||
opts.port = uri.port;
|
||
if (uri.query) opts.query = uri.query;
|
||
} else if (opts.host) {
|
||
opts.hostname = parseuri(opts.host).host;
|
||
}
|
||
|
||
this.secure = null != opts.secure ? opts.secure :
|
||
(global.location && 'https:' == location.protocol);
|
||
|
||
if (opts.hostname && !opts.port) {
|
||
// if no port is specified manually, use the protocol default
|
||
opts.port = this.secure ? '443' : '80';
|
||
}
|
||
|
||
this.agent = opts.agent || false;
|
||
this.hostname = opts.hostname ||
|
||
(global.location ? location.hostname : 'localhost');
|
||
this.port = opts.port || (global.location && location.port ?
|
||
location.port :
|
||
(this.secure ? 443 : 80));
|
||
this.query = opts.query || {};
|
||
if ('string' == typeof this.query) this.query = parseqs.decode(this.query);
|
||
this.upgrade = false !== opts.upgrade;
|
||
this.path = (opts.path || '/engine.io').replace(/\/$/, '') + '/';
|
||
this.forceJSONP = !!opts.forceJSONP;
|
||
this.jsonp = false !== opts.jsonp;
|
||
this.forceBase64 = !!opts.forceBase64;
|
||
this.enablesXDR = !!opts.enablesXDR;
|
||
this.timestampParam = opts.timestampParam || 't';
|
||
this.timestampRequests = opts.timestampRequests;
|
||
this.transports = opts.transports || ['polling', 'websocket'];
|
||
this.readyState = '';
|
||
this.writeBuffer = [];
|
||
this.policyPort = opts.policyPort || 843;
|
||
this.rememberUpgrade = opts.rememberUpgrade || false;
|
||
this.binaryType = null;
|
||
this.onlyBinaryUpgrades = opts.onlyBinaryUpgrades;
|
||
this.perMessageDeflate = false !== opts.perMessageDeflate ? (opts.perMessageDeflate || {}) : false;
|
||
|
||
if (true === this.perMessageDeflate) this.perMessageDeflate = {};
|
||
if (this.perMessageDeflate && null == this.perMessageDeflate.threshold) {
|
||
this.perMessageDeflate.threshold = 1024;
|
||
}
|
||
|
||
// SSL options for Node.js client
|
||
this.pfx = opts.pfx || null;
|
||
this.key = opts.key || null;
|
||
this.passphrase = opts.passphrase || null;
|
||
this.cert = opts.cert || null;
|
||
this.ca = opts.ca || null;
|
||
this.ciphers = opts.ciphers || null;
|
||
this.rejectUnauthorized = opts.rejectUnauthorized === undefined ? null : opts.rejectUnauthorized;
|
||
|
||
// other options for Node.js client
|
||
var freeGlobal = typeof global == 'object' && global;
|
||
if (freeGlobal.global === freeGlobal) {
|
||
if (opts.extraHeaders && Object.keys(opts.extraHeaders).length > 0) {
|
||
this.extraHeaders = opts.extraHeaders;
|
||
}
|
||
}
|
||
|
||
this.open();
|
||
}
|
||
|
||
Socket.priorWebsocketSuccess = false;
|
||
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/
|
||
|
||
Emitter(Socket.prototype);
|
||
|
||
/**
|
||
* Protocol version.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Socket.protocol = parser.protocol; // this is an int
|
||
|
||
/**
|
||
* Expose deps for legacy compatibility
|
||
* and standalone browser access.
|
||
*/
|
||
|
||
Socket.Socket = Socket;
|
||
Socket.Transport = require('./transport');
|
||
Socket.transports = require('./transports');
|
||
Socket.parser = require('engine.io-parser');
|
||
|
||
/**
|
||
* Creates transport of the given type.
|
||
*
|
||
* @param {String} transport name
|
||
* @return {Transport}
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.createTransport = function (name) {
|
||
debug('creating transport "%s"', name);
|
||
var query = clone(this.query);
|
||
|
||
// append engine.io protocol identifier
|
||
query.EIO = parser.protocol;
|
||
|
||
// transport name
|
||
query.transport = name;
|
||
|
||
// session id if we already have one
|
||
if (this.id) query.sid = this.id;
|
||
|
||
var transport = new transports[name]({
|
||
agent: this.agent,
|
||
hostname: this.hostname,
|
||
port: this.port,
|
||
secure: this.secure,
|
||
path: this.path,
|
||
query: query,
|
||
forceJSONP: this.forceJSONP,
|
||
jsonp: this.jsonp,
|
||
forceBase64: this.forceBase64,
|
||
enablesXDR: this.enablesXDR,
|
||
timestampRequests: this.timestampRequests,
|
||
timestampParam: this.timestampParam,
|
||
policyPort: this.policyPort,
|
||
socket: this,
|
||
pfx: this.pfx,
|
||
key: this.key,
|
||
passphrase: this.passphrase,
|
||
cert: this.cert,
|
||
ca: this.ca,
|
||
ciphers: this.ciphers,
|
||
rejectUnauthorized: this.rejectUnauthorized,
|
||
perMessageDeflate: this.perMessageDeflate,
|
||
extraHeaders: this.extraHeaders
|
||
});
|
||
|
||
return transport;
|
||
};
|
||
|
||
function clone (obj) {
|
||
var o = {};
|
||
for (var i in obj) {
|
||
if (obj.hasOwnProperty(i)) {
|
||
o[i] = obj[i];
|
||
}
|
||
}
|
||
return o;
|
||
}
|
||
|
||
/**
|
||
* Initializes transport to use and starts probe.
|
||
*
|
||
* @api private
|
||
*/
|
||
Socket.prototype.open = function () {
|
||
var transport;
|
||
if (this.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf('websocket') != -1) {
|
||
transport = 'websocket';
|
||
} else if (0 === this.transports.length) {
|
||
// Emit error on next tick so it can be listened to
|
||
var self = this;
|
||
setTimeout(function() {
|
||
self.emit('error', 'No transports available');
|
||
}, 0);
|
||
return;
|
||
} else {
|
||
transport = this.transports[0];
|
||
}
|
||
this.readyState = 'opening';
|
||
|
||
// Retry with the next transport if the transport is disabled (jsonp: false)
|
||
try {
|
||
transport = this.createTransport(transport);
|
||
} catch (e) {
|
||
this.transports.shift();
|
||
this.open();
|
||
return;
|
||
}
|
||
|
||
transport.open();
|
||
this.setTransport(transport);
|
||
};
|
||
|
||
/**
|
||
* Sets the current transport. Disables the existing one (if any).
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.setTransport = function(transport){
|
||
debug('setting transport %s', transport.name);
|
||
var self = this;
|
||
|
||
if (this.transport) {
|
||
debug('clearing existing transport %s', this.transport.name);
|
||
this.transport.removeAllListeners();
|
||
}
|
||
|
||
// set up transport
|
||
this.transport = transport;
|
||
|
||
// set up transport listeners
|
||
transport
|
||
.on('drain', function(){
|
||
self.onDrain();
|
||
})
|
||
.on('packet', function(packet){
|
||
self.onPacket(packet);
|
||
})
|
||
.on('error', function(e){
|
||
self.onError(e);
|
||
})
|
||
.on('close', function(){
|
||
self.onClose('transport close');
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Probes a transport.
|
||
*
|
||
* @param {String} transport name
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.probe = function (name) {
|
||
debug('probing transport "%s"', name);
|
||
var transport = this.createTransport(name, { probe: 1 })
|
||
, failed = false
|
||
, self = this;
|
||
|
||
Socket.priorWebsocketSuccess = false;
|
||
|
||
function onTransportOpen(){
|
||
if (self.onlyBinaryUpgrades) {
|
||
var upgradeLosesBinary = !this.supportsBinary && self.transport.supportsBinary;
|
||
failed = failed || upgradeLosesBinary;
|
||
}
|
||
if (failed) return;
|
||
|
||
debug('probe transport "%s" opened', name);
|
||
transport.send([{ type: 'ping', data: 'probe' }]);
|
||
transport.once('packet', function (msg) {
|
||
if (failed) return;
|
||
if ('pong' == msg.type && 'probe' == msg.data) {
|
||
debug('probe transport "%s" pong', name);
|
||
self.upgrading = true;
|
||
self.emit('upgrading', transport);
|
||
if (!transport) return;
|
||
Socket.priorWebsocketSuccess = 'websocket' == transport.name;
|
||
|
||
debug('pausing current transport "%s"', self.transport.name);
|
||
self.transport.pause(function () {
|
||
if (failed) return;
|
||
if ('closed' == self.readyState) return;
|
||
debug('changing transport and sending upgrade packet');
|
||
|
||
cleanup();
|
||
|
||
self.setTransport(transport);
|
||
transport.send([{ type: 'upgrade' }]);
|
||
self.emit('upgrade', transport);
|
||
transport = null;
|
||
self.upgrading = false;
|
||
self.flush();
|
||
});
|
||
} else {
|
||
debug('probe transport "%s" failed', name);
|
||
var err = new Error('probe error');
|
||
err.transport = transport.name;
|
||
self.emit('upgradeError', err);
|
||
}
|
||
});
|
||
}
|
||
|
||
function freezeTransport() {
|
||
if (failed) return;
|
||
|
||
// Any callback called by transport should be ignored since now
|
||
failed = true;
|
||
|
||
cleanup();
|
||
|
||
transport.close();
|
||
transport = null;
|
||
}
|
||
|
||
//Handle any error that happens while probing
|
||
function onerror(err) {
|
||
var error = new Error('probe error: ' + err);
|
||
error.transport = transport.name;
|
||
|
||
freezeTransport();
|
||
|
||
debug('probe transport "%s" failed because of error: %s', name, err);
|
||
|
||
self.emit('upgradeError', error);
|
||
}
|
||
|
||
function onTransportClose(){
|
||
onerror("transport closed");
|
||
}
|
||
|
||
//When the socket is closed while we're probing
|
||
function onclose(){
|
||
onerror("socket closed");
|
||
}
|
||
|
||
//When the socket is upgraded while we're probing
|
||
function onupgrade(to){
|
||
if (transport && to.name != transport.name) {
|
||
debug('"%s" works - aborting "%s"', to.name, transport.name);
|
||
freezeTransport();
|
||
}
|
||
}
|
||
|
||
//Remove all listeners on the transport and on self
|
||
function cleanup(){
|
||
transport.removeListener('open', onTransportOpen);
|
||
transport.removeListener('error', onerror);
|
||
transport.removeListener('close', onTransportClose);
|
||
self.removeListener('close', onclose);
|
||
self.removeListener('upgrading', onupgrade);
|
||
}
|
||
|
||
transport.once('open', onTransportOpen);
|
||
transport.once('error', onerror);
|
||
transport.once('close', onTransportClose);
|
||
|
||
this.once('close', onclose);
|
||
this.once('upgrading', onupgrade);
|
||
|
||
transport.open();
|
||
|
||
};
|
||
|
||
/**
|
||
* Called when connection is deemed open.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Socket.prototype.onOpen = function () {
|
||
debug('socket open');
|
||
this.readyState = 'open';
|
||
Socket.priorWebsocketSuccess = 'websocket' == this.transport.name;
|
||
this.emit('open');
|
||
this.flush();
|
||
|
||
// we check for `readyState` in case an `open`
|
||
// listener already closed the socket
|
||
if ('open' == this.readyState && this.upgrade && this.transport.pause) {
|
||
debug('starting upgrade probes');
|
||
for (var i = 0, l = this.upgrades.length; i < l; i++) {
|
||
this.probe(this.upgrades[i]);
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Handles a packet.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onPacket = function (packet) {
|
||
if ('opening' == this.readyState || 'open' == this.readyState) {
|
||
debug('socket receive: type "%s", data "%s"', packet.type, packet.data);
|
||
|
||
this.emit('packet', packet);
|
||
|
||
// Socket is live - any packet counts
|
||
this.emit('heartbeat');
|
||
|
||
switch (packet.type) {
|
||
case 'open':
|
||
this.onHandshake(parsejson(packet.data));
|
||
break;
|
||
|
||
case 'pong':
|
||
this.setPing();
|
||
this.emit('pong');
|
||
break;
|
||
|
||
case 'error':
|
||
var err = new Error('server error');
|
||
err.code = packet.data;
|
||
this.onError(err);
|
||
break;
|
||
|
||
case 'message':
|
||
this.emit('data', packet.data);
|
||
this.emit('message', packet.data);
|
||
break;
|
||
}
|
||
} else {
|
||
debug('packet received with socket readyState "%s"', this.readyState);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Called upon handshake completion.
|
||
*
|
||
* @param {Object} handshake obj
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onHandshake = function (data) {
|
||
this.emit('handshake', data);
|
||
this.id = data.sid;
|
||
this.transport.query.sid = data.sid;
|
||
this.upgrades = this.filterUpgrades(data.upgrades);
|
||
this.pingInterval = data.pingInterval;
|
||
this.pingTimeout = data.pingTimeout;
|
||
this.onOpen();
|
||
// In case open handler closes socket
|
||
if ('closed' == this.readyState) return;
|
||
this.setPing();
|
||
|
||
// Prolong liveness of socket on heartbeat
|
||
this.removeListener('heartbeat', this.onHeartbeat);
|
||
this.on('heartbeat', this.onHeartbeat);
|
||
};
|
||
|
||
/**
|
||
* Resets ping timeout.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onHeartbeat = function (timeout) {
|
||
clearTimeout(this.pingTimeoutTimer);
|
||
var self = this;
|
||
self.pingTimeoutTimer = setTimeout(function () {
|
||
if ('closed' == self.readyState) return;
|
||
self.onClose('ping timeout');
|
||
}, timeout || (self.pingInterval + self.pingTimeout));
|
||
};
|
||
|
||
/**
|
||
* Pings server every `this.pingInterval` and expects response
|
||
* within `this.pingTimeout` or closes connection.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.setPing = function () {
|
||
var self = this;
|
||
clearTimeout(self.pingIntervalTimer);
|
||
self.pingIntervalTimer = setTimeout(function () {
|
||
debug('writing ping packet - expecting pong within %sms', self.pingTimeout);
|
||
self.ping();
|
||
self.onHeartbeat(self.pingTimeout);
|
||
}, self.pingInterval);
|
||
};
|
||
|
||
/**
|
||
* Sends a ping packet.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.ping = function () {
|
||
var self = this;
|
||
this.sendPacket('ping', function(){
|
||
self.emit('ping');
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Called on `drain` event
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onDrain = function() {
|
||
this.writeBuffer.splice(0, this.prevBufferLen);
|
||
|
||
// setting prevBufferLen = 0 is very important
|
||
// for example, when upgrading, upgrade packet is sent over,
|
||
// and a nonzero prevBufferLen could cause problems on `drain`
|
||
this.prevBufferLen = 0;
|
||
|
||
if (0 === this.writeBuffer.length) {
|
||
this.emit('drain');
|
||
} else {
|
||
this.flush();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Flush write buffers.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.flush = function () {
|
||
if ('closed' != this.readyState && this.transport.writable &&
|
||
!this.upgrading && this.writeBuffer.length) {
|
||
debug('flushing %d packets in socket', this.writeBuffer.length);
|
||
this.transport.send(this.writeBuffer);
|
||
// keep track of current length of writeBuffer
|
||
// splice writeBuffer and callbackBuffer on `drain`
|
||
this.prevBufferLen = this.writeBuffer.length;
|
||
this.emit('flush');
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Sends a message.
|
||
*
|
||
* @param {String} message.
|
||
* @param {Function} callback function.
|
||
* @param {Object} options.
|
||
* @return {Socket} for chaining.
|
||
* @api public
|
||
*/
|
||
|
||
Socket.prototype.write =
|
||
Socket.prototype.send = function (msg, options, fn) {
|
||
this.sendPacket('message', msg, options, fn);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sends a packet.
|
||
*
|
||
* @param {String} packet type.
|
||
* @param {String} data.
|
||
* @param {Object} options.
|
||
* @param {Function} callback function.
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.sendPacket = function (type, data, options, fn) {
|
||
if('function' == typeof data) {
|
||
fn = data;
|
||
data = undefined;
|
||
}
|
||
|
||
if ('function' == typeof options) {
|
||
fn = options;
|
||
options = null;
|
||
}
|
||
|
||
if ('closing' == this.readyState || 'closed' == this.readyState) {
|
||
return;
|
||
}
|
||
|
||
options = options || {};
|
||
options.compress = false !== options.compress;
|
||
|
||
var packet = {
|
||
type: type,
|
||
data: data,
|
||
options: options
|
||
};
|
||
this.emit('packetCreate', packet);
|
||
this.writeBuffer.push(packet);
|
||
if (fn) this.once('flush', fn);
|
||
this.flush();
|
||
};
|
||
|
||
/**
|
||
* Closes the connection.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.close = function () {
|
||
if ('opening' == this.readyState || 'open' == this.readyState) {
|
||
this.readyState = 'closing';
|
||
|
||
var self = this;
|
||
|
||
if (this.writeBuffer.length) {
|
||
this.once('drain', function() {
|
||
if (this.upgrading) {
|
||
waitForUpgrade();
|
||
} else {
|
||
close();
|
||
}
|
||
});
|
||
} else if (this.upgrading) {
|
||
waitForUpgrade();
|
||
} else {
|
||
close();
|
||
}
|
||
}
|
||
|
||
function close() {
|
||
self.onClose('forced close');
|
||
debug('socket closing - telling transport to close');
|
||
self.transport.close();
|
||
}
|
||
|
||
function cleanupAndClose() {
|
||
self.removeListener('upgrade', cleanupAndClose);
|
||
self.removeListener('upgradeError', cleanupAndClose);
|
||
close();
|
||
}
|
||
|
||
function waitForUpgrade() {
|
||
// wait for upgrade to finish since we can't send packets while pausing a transport
|
||
self.once('upgrade', cleanupAndClose);
|
||
self.once('upgradeError', cleanupAndClose);
|
||
}
|
||
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Called upon transport error
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onError = function (err) {
|
||
debug('socket error %j', err);
|
||
Socket.priorWebsocketSuccess = false;
|
||
this.emit('error', err);
|
||
this.onClose('transport error', err);
|
||
};
|
||
|
||
/**
|
||
* Called upon transport close.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onClose = function (reason, desc) {
|
||
if ('opening' == this.readyState || 'open' == this.readyState || 'closing' == this.readyState) {
|
||
debug('socket close with reason: "%s"', reason);
|
||
var self = this;
|
||
|
||
// clear timers
|
||
clearTimeout(this.pingIntervalTimer);
|
||
clearTimeout(this.pingTimeoutTimer);
|
||
|
||
// stop event from firing again for transport
|
||
this.transport.removeAllListeners('close');
|
||
|
||
// ensure transport won't stay open
|
||
this.transport.close();
|
||
|
||
// ignore further transport communication
|
||
this.transport.removeAllListeners();
|
||
|
||
// set ready state
|
||
this.readyState = 'closed';
|
||
|
||
// clear session id
|
||
this.id = null;
|
||
|
||
// emit close event
|
||
this.emit('close', reason, desc);
|
||
|
||
// clean buffers after, so users can still
|
||
// grab the buffers on `close` event
|
||
self.writeBuffer = [];
|
||
self.prevBufferLen = 0;
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Filters upgrades, returning only those matching client transports.
|
||
*
|
||
* @param {Array} server upgrades
|
||
* @api private
|
||
*
|
||
*/
|
||
|
||
Socket.prototype.filterUpgrades = function (upgrades) {
|
||
var filteredUpgrades = [];
|
||
for (var i = 0, j = upgrades.length; i<j; i++) {
|
||
if (~index(this.transports, upgrades[i])) filteredUpgrades.push(upgrades[i]);
|
||
}
|
||
return filteredUpgrades;
|
||
};
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./transport":51,"./transports":52,"component-emitter":14,"debug":46,"engine.io-parser":58,"indexof":63,"parsejson":134,"parseqs":135,"parseuri":136}],51:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/engine.io-client/lib/transport.js", module);
|
||
(function(){
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var parser = require('engine.io-parser');
|
||
var Emitter = require('component-emitter');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = Transport;
|
||
|
||
/**
|
||
* Transport abstract constructor.
|
||
*
|
||
* @param {Object} options.
|
||
* @api private
|
||
*/
|
||
|
||
function Transport (opts) {
|
||
this.path = opts.path;
|
||
this.hostname = opts.hostname;
|
||
this.port = opts.port;
|
||
this.secure = opts.secure;
|
||
this.query = opts.query;
|
||
this.timestampParam = opts.timestampParam;
|
||
this.timestampRequests = opts.timestampRequests;
|
||
this.readyState = '';
|
||
this.agent = opts.agent || false;
|
||
this.socket = opts.socket;
|
||
this.enablesXDR = opts.enablesXDR;
|
||
|
||
// SSL options for Node.js client
|
||
this.pfx = opts.pfx;
|
||
this.key = opts.key;
|
||
this.passphrase = opts.passphrase;
|
||
this.cert = opts.cert;
|
||
this.ca = opts.ca;
|
||
this.ciphers = opts.ciphers;
|
||
this.rejectUnauthorized = opts.rejectUnauthorized;
|
||
|
||
// other options for Node.js client
|
||
this.extraHeaders = opts.extraHeaders;
|
||
}
|
||
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/
|
||
|
||
Emitter(Transport.prototype);
|
||
|
||
/**
|
||
* Emits an error.
|
||
*
|
||
* @param {String} str
|
||
* @return {Transport} for chaining
|
||
* @api public
|
||
*/
|
||
|
||
Transport.prototype.onError = function (msg, desc) {
|
||
var err = new Error(msg);
|
||
err.type = 'TransportError';
|
||
err.description = desc;
|
||
this.emit('error', err);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Opens the transport.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Transport.prototype.open = function () {
|
||
if ('closed' == this.readyState || '' == this.readyState) {
|
||
this.readyState = 'opening';
|
||
this.doOpen();
|
||
}
|
||
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Closes the transport.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Transport.prototype.close = function () {
|
||
if ('opening' == this.readyState || 'open' == this.readyState) {
|
||
this.doClose();
|
||
this.onClose();
|
||
}
|
||
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sends multiple packets.
|
||
*
|
||
* @param {Array} packets
|
||
* @api private
|
||
*/
|
||
|
||
Transport.prototype.send = function(packets){
|
||
if ('open' == this.readyState) {
|
||
this.write(packets);
|
||
} else {
|
||
throw new Error('Transport not open');
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Called upon open
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Transport.prototype.onOpen = function () {
|
||
this.readyState = 'open';
|
||
this.writable = true;
|
||
this.emit('open');
|
||
};
|
||
|
||
/**
|
||
* Called with data.
|
||
*
|
||
* @param {String} data
|
||
* @api private
|
||
*/
|
||
|
||
Transport.prototype.onData = function(data){
|
||
var packet = parser.decodePacket(data, this.socket.binaryType);
|
||
this.onPacket(packet);
|
||
};
|
||
|
||
/**
|
||
* Called with a decoded packet.
|
||
*/
|
||
|
||
Transport.prototype.onPacket = function (packet) {
|
||
this.emit('packet', packet);
|
||
};
|
||
|
||
/**
|
||
* Called upon close.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Transport.prototype.onClose = function () {
|
||
this.readyState = 'closed';
|
||
this.emit('close');
|
||
};
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"component-emitter":14,"engine.io-parser":58}],52:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/engine.io-client/lib/transports/index.js", module);
|
||
(function(){
|
||
(function (global){
|
||
/**
|
||
* Module dependencies
|
||
*/
|
||
|
||
var XMLHttpRequest = require('xmlhttprequest-ssl');
|
||
var XHR = require('./polling-xhr');
|
||
var JSONP = require('./polling-jsonp');
|
||
var websocket = require('./websocket');
|
||
|
||
/**
|
||
* Export transports.
|
||
*/
|
||
|
||
exports.polling = polling;
|
||
exports.websocket = websocket;
|
||
|
||
/**
|
||
* Polling transport polymorphic constructor.
|
||
* Decides on xhr vs jsonp based on feature detection.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
function polling(opts){
|
||
var xhr;
|
||
var xd = false;
|
||
var xs = false;
|
||
var jsonp = false !== opts.jsonp;
|
||
|
||
if (global.location) {
|
||
var isSSL = 'https:' == location.protocol;
|
||
var port = location.port;
|
||
|
||
// some user agents have empty `location.port`
|
||
if (!port) {
|
||
port = isSSL ? 443 : 80;
|
||
}
|
||
|
||
xd = opts.hostname != location.hostname || port != opts.port;
|
||
xs = opts.secure != isSSL;
|
||
}
|
||
|
||
opts.xdomain = xd;
|
||
opts.xscheme = xs;
|
||
xhr = new XMLHttpRequest(opts);
|
||
|
||
if ('open' in xhr && !opts.forceJSONP) {
|
||
return new XHR(opts);
|
||
} else {
|
||
if (!jsonp) throw new Error('JSONP disabled');
|
||
return new JSONP(opts);
|
||
}
|
||
}
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./polling-jsonp":53,"./polling-xhr":54,"./websocket":56,"xmlhttprequest-ssl":57}],53:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/engine.io-client/lib/transports/polling-jsonp.js", module);
|
||
(function(){
|
||
(function (global){
|
||
|
||
/**
|
||
* Module requirements.
|
||
*/
|
||
|
||
var Polling = require('./polling');
|
||
var inherit = require('component-inherit');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = JSONPPolling;
|
||
|
||
/**
|
||
* Cached regular expressions.
|
||
*/
|
||
|
||
var rNewline = /\n/g;
|
||
var rEscapedNewline = /\\n/g;
|
||
|
||
/**
|
||
* Global JSONP callbacks.
|
||
*/
|
||
|
||
var callbacks;
|
||
|
||
/**
|
||
* Callbacks count.
|
||
*/
|
||
|
||
var index = 0;
|
||
|
||
/**
|
||
* Noop.
|
||
*/
|
||
|
||
function empty () { }
|
||
|
||
/**
|
||
* JSONP Polling constructor.
|
||
*
|
||
* @param {Object} opts.
|
||
* @api public
|
||
*/
|
||
|
||
function JSONPPolling (opts) {
|
||
Polling.call(this, opts);
|
||
|
||
this.query = this.query || {};
|
||
|
||
// define global callbacks array if not present
|
||
// we do this here (lazily) to avoid unneeded global pollution
|
||
if (!callbacks) {
|
||
// we need to consider multiple engines in the same page
|
||
if (!global.___eio) global.___eio = [];
|
||
callbacks = global.___eio;
|
||
}
|
||
|
||
// callback identifier
|
||
this.index = callbacks.length;
|
||
|
||
// add callback to jsonp global
|
||
var self = this;
|
||
callbacks.push(function (msg) {
|
||
self.onData(msg);
|
||
});
|
||
|
||
// append to query string
|
||
this.query.j = this.index;
|
||
|
||
// prevent spurious errors from being emitted when the window is unloaded
|
||
if (global.document && global.addEventListener) {
|
||
global.addEventListener('beforeunload', function () {
|
||
if (self.script) self.script.onerror = empty;
|
||
}, false);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Inherits from Polling.
|
||
*/
|
||
|
||
inherit(JSONPPolling, Polling);
|
||
|
||
/*
|
||
* JSONP only supports binary as base64 encoded strings
|
||
*/
|
||
|
||
JSONPPolling.prototype.supportsBinary = false;
|
||
|
||
/**
|
||
* Closes the socket.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
JSONPPolling.prototype.doClose = function () {
|
||
if (this.script) {
|
||
this.script.parentNode.removeChild(this.script);
|
||
this.script = null;
|
||
}
|
||
|
||
if (this.form) {
|
||
this.form.parentNode.removeChild(this.form);
|
||
this.form = null;
|
||
this.iframe = null;
|
||
}
|
||
|
||
Polling.prototype.doClose.call(this);
|
||
};
|
||
|
||
/**
|
||
* Starts a poll cycle.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
JSONPPolling.prototype.doPoll = function () {
|
||
var self = this;
|
||
var script = document.createElement('script');
|
||
|
||
if (this.script) {
|
||
this.script.parentNode.removeChild(this.script);
|
||
this.script = null;
|
||
}
|
||
|
||
script.async = true;
|
||
script.src = this.uri();
|
||
script.onerror = function(e){
|
||
self.onError('jsonp poll error',e);
|
||
};
|
||
|
||
var insertAt = document.getElementsByTagName('script')[0];
|
||
if (insertAt) {
|
||
insertAt.parentNode.insertBefore(script, insertAt);
|
||
}
|
||
else {
|
||
(document.head || document.body).appendChild(script);
|
||
}
|
||
this.script = script;
|
||
|
||
var isUAgecko = 'undefined' != typeof navigator && /gecko/i.test(navigator.userAgent);
|
||
|
||
if (isUAgecko) {
|
||
setTimeout(function () {
|
||
var iframe = document.createElement('iframe');
|
||
document.body.appendChild(iframe);
|
||
document.body.removeChild(iframe);
|
||
}, 100);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Writes with a hidden iframe.
|
||
*
|
||
* @param {String} data to send
|
||
* @param {Function} called upon flush.
|
||
* @api private
|
||
*/
|
||
|
||
JSONPPolling.prototype.doWrite = function (data, fn) {
|
||
var self = this;
|
||
|
||
if (!this.form) {
|
||
var form = document.createElement('form');
|
||
var area = document.createElement('textarea');
|
||
var id = this.iframeId = 'eio_iframe_' + this.index;
|
||
var iframe;
|
||
|
||
form.className = 'socketio';
|
||
form.style.position = 'absolute';
|
||
form.style.top = '-1000px';
|
||
form.style.left = '-1000px';
|
||
form.target = id;
|
||
form.method = 'POST';
|
||
form.setAttribute('accept-charset', 'utf-8');
|
||
area.name = 'd';
|
||
form.appendChild(area);
|
||
document.body.appendChild(form);
|
||
|
||
this.form = form;
|
||
this.area = area;
|
||
}
|
||
|
||
this.form.action = this.uri();
|
||
|
||
function complete () {
|
||
initIframe();
|
||
fn();
|
||
}
|
||
|
||
function initIframe () {
|
||
if (self.iframe) {
|
||
try {
|
||
self.form.removeChild(self.iframe);
|
||
} catch (e) {
|
||
self.onError('jsonp polling iframe removal error', e);
|
||
}
|
||
}
|
||
|
||
try {
|
||
// ie6 dynamic iframes with target="" support (thanks Chris Lambacher)
|
||
var html = '<iframe src="javascript:0" name="'+ self.iframeId +'">';
|
||
iframe = document.createElement(html);
|
||
} catch (e) {
|
||
iframe = document.createElement('iframe');
|
||
iframe.name = self.iframeId;
|
||
iframe.src = 'javascript:0';
|
||
}
|
||
|
||
iframe.id = self.iframeId;
|
||
|
||
self.form.appendChild(iframe);
|
||
self.iframe = iframe;
|
||
}
|
||
|
||
initIframe();
|
||
|
||
// escape \n to prevent it from being converted into \r\n by some UAs
|
||
// double escaping is required for escaped new lines because unescaping of new lines can be done safely on server-side
|
||
data = data.replace(rEscapedNewline, '\\\n');
|
||
this.area.value = data.replace(rNewline, '\\n');
|
||
|
||
try {
|
||
this.form.submit();
|
||
} catch(e) {}
|
||
|
||
if (this.iframe.attachEvent) {
|
||
this.iframe.onreadystatechange = function(){
|
||
if (self.iframe.readyState == 'complete') {
|
||
complete();
|
||
}
|
||
};
|
||
} else {
|
||
this.iframe.onload = complete;
|
||
}
|
||
};
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./polling":55,"component-inherit":15}],54:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/engine.io-client/lib/transports/polling-xhr.js", module);
|
||
(function(){
|
||
(function (global){
|
||
/**
|
||
* Module requirements.
|
||
*/
|
||
|
||
var XMLHttpRequest = require('xmlhttprequest-ssl');
|
||
var Polling = require('./polling');
|
||
var Emitter = require('component-emitter');
|
||
var inherit = require('component-inherit');
|
||
var debug = require('debug')('engine.io-client:polling-xhr');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = XHR;
|
||
module.exports.Request = Request;
|
||
|
||
/**
|
||
* Empty function
|
||
*/
|
||
|
||
function empty(){}
|
||
|
||
/**
|
||
* XHR Polling constructor.
|
||
*
|
||
* @param {Object} opts
|
||
* @api public
|
||
*/
|
||
|
||
function XHR(opts){
|
||
Polling.call(this, opts);
|
||
|
||
if (global.location) {
|
||
var isSSL = 'https:' == location.protocol;
|
||
var port = location.port;
|
||
|
||
// some user agents have empty `location.port`
|
||
if (!port) {
|
||
port = isSSL ? 443 : 80;
|
||
}
|
||
|
||
this.xd = opts.hostname != global.location.hostname ||
|
||
port != opts.port;
|
||
this.xs = opts.secure != isSSL;
|
||
} else {
|
||
this.extraHeaders = opts.extraHeaders;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Inherits from Polling.
|
||
*/
|
||
|
||
inherit(XHR, Polling);
|
||
|
||
/**
|
||
* XHR supports binary
|
||
*/
|
||
|
||
XHR.prototype.supportsBinary = true;
|
||
|
||
/**
|
||
* Creates a request.
|
||
*
|
||
* @param {String} method
|
||
* @api private
|
||
*/
|
||
|
||
XHR.prototype.request = function(opts){
|
||
opts = opts || {};
|
||
opts.uri = this.uri();
|
||
opts.xd = this.xd;
|
||
opts.xs = this.xs;
|
||
opts.agent = this.agent || false;
|
||
opts.supportsBinary = this.supportsBinary;
|
||
opts.enablesXDR = this.enablesXDR;
|
||
|
||
// SSL options for Node.js client
|
||
opts.pfx = this.pfx;
|
||
opts.key = this.key;
|
||
opts.passphrase = this.passphrase;
|
||
opts.cert = this.cert;
|
||
opts.ca = this.ca;
|
||
opts.ciphers = this.ciphers;
|
||
opts.rejectUnauthorized = this.rejectUnauthorized;
|
||
|
||
// other options for Node.js client
|
||
opts.extraHeaders = this.extraHeaders;
|
||
|
||
return new Request(opts);
|
||
};
|
||
|
||
/**
|
||
* Sends data.
|
||
*
|
||
* @param {String} data to send.
|
||
* @param {Function} called upon flush.
|
||
* @api private
|
||
*/
|
||
|
||
XHR.prototype.doWrite = function(data, fn){
|
||
var isBinary = typeof data !== 'string' && data !== undefined;
|
||
var req = this.request({ method: 'POST', data: data, isBinary: isBinary });
|
||
var self = this;
|
||
req.on('success', fn);
|
||
req.on('error', function(err){
|
||
self.onError('xhr post error', err);
|
||
});
|
||
this.sendXhr = req;
|
||
};
|
||
|
||
/**
|
||
* Starts a poll cycle.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
XHR.prototype.doPoll = function(){
|
||
debug('xhr poll');
|
||
var req = this.request();
|
||
var self = this;
|
||
req.on('data', function(data){
|
||
self.onData(data);
|
||
});
|
||
req.on('error', function(err){
|
||
self.onError('xhr poll error', err);
|
||
});
|
||
this.pollXhr = req;
|
||
};
|
||
|
||
/**
|
||
* Request constructor
|
||
*
|
||
* @param {Object} options
|
||
* @api public
|
||
*/
|
||
|
||
function Request(opts){
|
||
this.method = opts.method || 'GET';
|
||
this.uri = opts.uri;
|
||
this.xd = !!opts.xd;
|
||
this.xs = !!opts.xs;
|
||
this.async = false !== opts.async;
|
||
this.data = undefined != opts.data ? opts.data : null;
|
||
this.agent = opts.agent;
|
||
this.isBinary = opts.isBinary;
|
||
this.supportsBinary = opts.supportsBinary;
|
||
this.enablesXDR = opts.enablesXDR;
|
||
|
||
// SSL options for Node.js client
|
||
this.pfx = opts.pfx;
|
||
this.key = opts.key;
|
||
this.passphrase = opts.passphrase;
|
||
this.cert = opts.cert;
|
||
this.ca = opts.ca;
|
||
this.ciphers = opts.ciphers;
|
||
this.rejectUnauthorized = opts.rejectUnauthorized;
|
||
|
||
// other options for Node.js client
|
||
this.extraHeaders = opts.extraHeaders;
|
||
|
||
this.create();
|
||
}
|
||
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/
|
||
|
||
Emitter(Request.prototype);
|
||
|
||
/**
|
||
* Creates the XHR object and sends the request.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Request.prototype.create = function(){
|
||
var opts = { agent: this.agent, xdomain: this.xd, xscheme: this.xs, enablesXDR: this.enablesXDR };
|
||
|
||
// SSL options for Node.js client
|
||
opts.pfx = this.pfx;
|
||
opts.key = this.key;
|
||
opts.passphrase = this.passphrase;
|
||
opts.cert = this.cert;
|
||
opts.ca = this.ca;
|
||
opts.ciphers = this.ciphers;
|
||
opts.rejectUnauthorized = this.rejectUnauthorized;
|
||
|
||
var xhr = this.xhr = new XMLHttpRequest(opts);
|
||
var self = this;
|
||
|
||
try {
|
||
debug('xhr open %s: %s', this.method, this.uri);
|
||
xhr.open(this.method, this.uri, this.async);
|
||
try {
|
||
if (this.extraHeaders) {
|
||
xhr.setDisableHeaderCheck(true);
|
||
for (var i in this.extraHeaders) {
|
||
if (this.extraHeaders.hasOwnProperty(i)) {
|
||
xhr.setRequestHeader(i, this.extraHeaders[i]);
|
||
}
|
||
}
|
||
}
|
||
} catch (e) {}
|
||
if (this.supportsBinary) {
|
||
// This has to be done after open because Firefox is stupid
|
||
// http://stackoverflow.com/questions/13216903/get-binary-data-with-xmlhttprequest-in-a-firefox-extension
|
||
xhr.responseType = 'arraybuffer';
|
||
}
|
||
|
||
if ('POST' == this.method) {
|
||
try {
|
||
if (this.isBinary) {
|
||
xhr.setRequestHeader('Content-type', 'application/octet-stream');
|
||
} else {
|
||
xhr.setRequestHeader('Content-type', 'text/plain;charset=UTF-8');
|
||
}
|
||
} catch (e) {}
|
||
}
|
||
|
||
// ie6 check
|
||
if ('withCredentials' in xhr) {
|
||
xhr.withCredentials = true;
|
||
}
|
||
|
||
if (this.hasXDR()) {
|
||
xhr.onload = function(){
|
||
self.onLoad();
|
||
};
|
||
xhr.onerror = function(){
|
||
self.onError(xhr.responseText);
|
||
};
|
||
} else {
|
||
xhr.onreadystatechange = function(){
|
||
if (4 != xhr.readyState) return;
|
||
if (200 == xhr.status || 1223 == xhr.status) {
|
||
self.onLoad();
|
||
} else {
|
||
// make sure the `error` event handler that's user-set
|
||
// does not throw in the same tick and gets caught here
|
||
setTimeout(function(){
|
||
self.onError(xhr.status);
|
||
}, 0);
|
||
}
|
||
};
|
||
}
|
||
|
||
debug('xhr data %s', this.data);
|
||
xhr.send(this.data);
|
||
} catch (e) {
|
||
// Need to defer since .create() is called directly fhrom the constructor
|
||
// and thus the 'error' event can only be only bound *after* this exception
|
||
// occurs. Therefore, also, we cannot throw here at all.
|
||
setTimeout(function() {
|
||
self.onError(e);
|
||
}, 0);
|
||
return;
|
||
}
|
||
|
||
if (global.document) {
|
||
this.index = Request.requestsCount++;
|
||
Request.requests[this.index] = this;
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Called upon successful response.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Request.prototype.onSuccess = function(){
|
||
this.emit('success');
|
||
this.cleanup();
|
||
};
|
||
|
||
/**
|
||
* Called if we have data.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Request.prototype.onData = function(data){
|
||
this.emit('data', data);
|
||
this.onSuccess();
|
||
};
|
||
|
||
/**
|
||
* Called upon error.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Request.prototype.onError = function(err){
|
||
this.emit('error', err);
|
||
this.cleanup(true);
|
||
};
|
||
|
||
/**
|
||
* Cleans up house.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Request.prototype.cleanup = function(fromError){
|
||
if ('undefined' == typeof this.xhr || null === this.xhr) {
|
||
return;
|
||
}
|
||
// xmlhttprequest
|
||
if (this.hasXDR()) {
|
||
this.xhr.onload = this.xhr.onerror = empty;
|
||
} else {
|
||
this.xhr.onreadystatechange = empty;
|
||
}
|
||
|
||
if (fromError) {
|
||
try {
|
||
this.xhr.abort();
|
||
} catch(e) {}
|
||
}
|
||
|
||
if (global.document) {
|
||
delete Request.requests[this.index];
|
||
}
|
||
|
||
this.xhr = null;
|
||
};
|
||
|
||
/**
|
||
* Called upon load.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Request.prototype.onLoad = function(){
|
||
var data;
|
||
try {
|
||
var contentType;
|
||
try {
|
||
contentType = this.xhr.getResponseHeader('Content-Type').split(';')[0];
|
||
} catch (e) {}
|
||
if (contentType === 'application/octet-stream') {
|
||
data = this.xhr.response;
|
||
} else {
|
||
if (!this.supportsBinary) {
|
||
data = this.xhr.responseText;
|
||
} else {
|
||
try {
|
||
data = String.fromCharCode.apply(null, new Uint8Array(this.xhr.response));
|
||
} catch (e) {
|
||
var ui8Arr = new Uint8Array(this.xhr.response);
|
||
var dataArray = [];
|
||
for (var idx = 0, length = ui8Arr.length; idx < length; idx++) {
|
||
dataArray.push(ui8Arr[idx]);
|
||
}
|
||
|
||
data = String.fromCharCode.apply(null, dataArray);
|
||
}
|
||
}
|
||
}
|
||
} catch (e) {
|
||
this.onError(e);
|
||
}
|
||
if (null != data) {
|
||
this.onData(data);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Check if it has XDomainRequest.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Request.prototype.hasXDR = function(){
|
||
return 'undefined' !== typeof global.XDomainRequest && !this.xs && this.enablesXDR;
|
||
};
|
||
|
||
/**
|
||
* Aborts the request.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Request.prototype.abort = function(){
|
||
this.cleanup();
|
||
};
|
||
|
||
/**
|
||
* Aborts pending requests when unloading the window. This is needed to prevent
|
||
* memory leaks (e.g. when using IE) and to ensure that no spurious error is
|
||
* emitted.
|
||
*/
|
||
|
||
if (global.document) {
|
||
Request.requestsCount = 0;
|
||
Request.requests = {};
|
||
if (global.attachEvent) {
|
||
global.attachEvent('onunload', unloadHandler);
|
||
} else if (global.addEventListener) {
|
||
global.addEventListener('beforeunload', unloadHandler, false);
|
||
}
|
||
}
|
||
|
||
function unloadHandler() {
|
||
for (var i in Request.requests) {
|
||
if (Request.requests.hasOwnProperty(i)) {
|
||
Request.requests[i].abort();
|
||
}
|
||
}
|
||
}
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./polling":55,"component-emitter":14,"component-inherit":15,"debug":46,"xmlhttprequest-ssl":57}],55:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/engine.io-client/lib/transports/polling.js", module);
|
||
(function(){
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var Transport = require('../transport');
|
||
var parseqs = require('parseqs');
|
||
var parser = require('engine.io-parser');
|
||
var inherit = require('component-inherit');
|
||
var yeast = require('yeast');
|
||
var debug = require('debug')('engine.io-client:polling');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = Polling;
|
||
|
||
/**
|
||
* Is XHR2 supported?
|
||
*/
|
||
|
||
var hasXHR2 = (function() {
|
||
var XMLHttpRequest = require('xmlhttprequest-ssl');
|
||
var xhr = new XMLHttpRequest({ xdomain: false });
|
||
return null != xhr.responseType;
|
||
})();
|
||
|
||
/**
|
||
* Polling interface.
|
||
*
|
||
* @param {Object} opts
|
||
* @api private
|
||
*/
|
||
|
||
function Polling(opts){
|
||
var forceBase64 = (opts && opts.forceBase64);
|
||
if (!hasXHR2 || forceBase64) {
|
||
this.supportsBinary = false;
|
||
}
|
||
Transport.call(this, opts);
|
||
}
|
||
|
||
/**
|
||
* Inherits from Transport.
|
||
*/
|
||
|
||
inherit(Polling, Transport);
|
||
|
||
/**
|
||
* Transport name.
|
||
*/
|
||
|
||
Polling.prototype.name = 'polling';
|
||
|
||
/**
|
||
* Opens the socket (triggers polling). We write a PING message to determine
|
||
* when the transport is open.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Polling.prototype.doOpen = function(){
|
||
this.poll();
|
||
};
|
||
|
||
/**
|
||
* Pauses polling.
|
||
*
|
||
* @param {Function} callback upon buffers are flushed and transport is paused
|
||
* @api private
|
||
*/
|
||
|
||
Polling.prototype.pause = function(onPause){
|
||
var pending = 0;
|
||
var self = this;
|
||
|
||
this.readyState = 'pausing';
|
||
|
||
function pause(){
|
||
debug('paused');
|
||
self.readyState = 'paused';
|
||
onPause();
|
||
}
|
||
|
||
if (this.polling || !this.writable) {
|
||
var total = 0;
|
||
|
||
if (this.polling) {
|
||
debug('we are currently polling - waiting to pause');
|
||
total++;
|
||
this.once('pollComplete', function(){
|
||
debug('pre-pause polling complete');
|
||
--total || pause();
|
||
});
|
||
}
|
||
|
||
if (!this.writable) {
|
||
debug('we are currently writing - waiting to pause');
|
||
total++;
|
||
this.once('drain', function(){
|
||
debug('pre-pause writing complete');
|
||
--total || pause();
|
||
});
|
||
}
|
||
} else {
|
||
pause();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Starts polling cycle.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Polling.prototype.poll = function(){
|
||
debug('polling');
|
||
this.polling = true;
|
||
this.doPoll();
|
||
this.emit('poll');
|
||
};
|
||
|
||
/**
|
||
* Overloads onData to detect payloads.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Polling.prototype.onData = function(data){
|
||
var self = this;
|
||
debug('polling got data %s', data);
|
||
var callback = function(packet, index, total) {
|
||
// if its the first message we consider the transport open
|
||
if ('opening' == self.readyState) {
|
||
self.onOpen();
|
||
}
|
||
|
||
// if its a close packet, we close the ongoing requests
|
||
if ('close' == packet.type) {
|
||
self.onClose();
|
||
return false;
|
||
}
|
||
|
||
// otherwise bypass onData and handle the message
|
||
self.onPacket(packet);
|
||
};
|
||
|
||
// decode payload
|
||
parser.decodePayload(data, this.socket.binaryType, callback);
|
||
|
||
// if an event did not trigger closing
|
||
if ('closed' != this.readyState) {
|
||
// if we got data we're not polling
|
||
this.polling = false;
|
||
this.emit('pollComplete');
|
||
|
||
if ('open' == this.readyState) {
|
||
this.poll();
|
||
} else {
|
||
debug('ignoring poll - transport state "%s"', this.readyState);
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* For polling, send a close packet.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Polling.prototype.doClose = function(){
|
||
var self = this;
|
||
|
||
function close(){
|
||
debug('writing close packet');
|
||
self.write([{ type: 'close' }]);
|
||
}
|
||
|
||
if ('open' == this.readyState) {
|
||
debug('transport open - closing');
|
||
close();
|
||
} else {
|
||
// in case we're trying to close while
|
||
// handshaking is in progress (GH-164)
|
||
debug('transport not open - deferring close');
|
||
this.once('open', close);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Writes a packets payload.
|
||
*
|
||
* @param {Array} data packets
|
||
* @param {Function} drain callback
|
||
* @api private
|
||
*/
|
||
|
||
Polling.prototype.write = function(packets){
|
||
var self = this;
|
||
this.writable = false;
|
||
var callbackfn = function() {
|
||
self.writable = true;
|
||
self.emit('drain');
|
||
};
|
||
|
||
var self = this;
|
||
parser.encodePayload(packets, this.supportsBinary, function(data) {
|
||
self.doWrite(data, callbackfn);
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Generates uri for connection.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Polling.prototype.uri = function(){
|
||
var query = this.query || {};
|
||
var schema = this.secure ? 'https' : 'http';
|
||
var port = '';
|
||
|
||
// cache busting is forced
|
||
if (false !== this.timestampRequests) {
|
||
query[this.timestampParam] = yeast();
|
||
}
|
||
|
||
if (!this.supportsBinary && !query.sid) {
|
||
query.b64 = 1;
|
||
}
|
||
|
||
query = parseqs.encode(query);
|
||
|
||
// avoid port if default for schema
|
||
if (this.port && (('https' == schema && this.port != 443) ||
|
||
('http' == schema && this.port != 80))) {
|
||
port = ':' + this.port;
|
||
}
|
||
|
||
// prepend ? to query
|
||
if (query.length) {
|
||
query = '?' + query;
|
||
}
|
||
|
||
var ipv6 = this.hostname.indexOf(':') !== -1;
|
||
return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;
|
||
};
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../transport":51,"component-inherit":15,"debug":46,"engine.io-parser":58,"parseqs":135,"xmlhttprequest-ssl":57,"yeast":154}],56:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/engine.io-client/lib/transports/websocket.js", module);
|
||
(function(){
|
||
(function (global){
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var Transport = require('../transport');
|
||
var parser = require('engine.io-parser');
|
||
var parseqs = require('parseqs');
|
||
var inherit = require('component-inherit');
|
||
var yeast = require('yeast');
|
||
var debug = require('debug')('engine.io-client:websocket');
|
||
var BrowserWebSocket = global.WebSocket || global.MozWebSocket;
|
||
|
||
/**
|
||
* Get either the `WebSocket` or `MozWebSocket` globals
|
||
* in the browser or try to resolve WebSocket-compatible
|
||
* interface exposed by `ws` for Node-like environment.
|
||
*/
|
||
|
||
var WebSocket = BrowserWebSocket;
|
||
if (!WebSocket && typeof window === 'undefined') {
|
||
try {
|
||
WebSocket = require('ws');
|
||
} catch (e) { }
|
||
}
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = WS;
|
||
|
||
/**
|
||
* WebSocket transport constructor.
|
||
*
|
||
* @api {Object} connection options
|
||
* @api public
|
||
*/
|
||
|
||
function WS(opts){
|
||
var forceBase64 = (opts && opts.forceBase64);
|
||
if (forceBase64) {
|
||
this.supportsBinary = false;
|
||
}
|
||
this.perMessageDeflate = opts.perMessageDeflate;
|
||
Transport.call(this, opts);
|
||
}
|
||
|
||
/**
|
||
* Inherits from Transport.
|
||
*/
|
||
|
||
inherit(WS, Transport);
|
||
|
||
/**
|
||
* Transport name.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
WS.prototype.name = 'websocket';
|
||
|
||
/*
|
||
* WebSockets support binary
|
||
*/
|
||
|
||
WS.prototype.supportsBinary = true;
|
||
|
||
/**
|
||
* Opens socket.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
WS.prototype.doOpen = function(){
|
||
if (!this.check()) {
|
||
// let probe timeout
|
||
return;
|
||
}
|
||
|
||
var self = this;
|
||
var uri = this.uri();
|
||
var protocols = void(0);
|
||
var opts = {
|
||
agent: this.agent,
|
||
perMessageDeflate: this.perMessageDeflate
|
||
};
|
||
|
||
// SSL options for Node.js client
|
||
opts.pfx = this.pfx;
|
||
opts.key = this.key;
|
||
opts.passphrase = this.passphrase;
|
||
opts.cert = this.cert;
|
||
opts.ca = this.ca;
|
||
opts.ciphers = this.ciphers;
|
||
opts.rejectUnauthorized = this.rejectUnauthorized;
|
||
if (this.extraHeaders) {
|
||
opts.headers = this.extraHeaders;
|
||
}
|
||
|
||
this.ws = BrowserWebSocket ? new WebSocket(uri) : new WebSocket(uri, protocols, opts);
|
||
|
||
if (this.ws.binaryType === undefined) {
|
||
this.supportsBinary = false;
|
||
}
|
||
|
||
if (this.ws.supports && this.ws.supports.binary) {
|
||
this.supportsBinary = true;
|
||
this.ws.binaryType = 'buffer';
|
||
} else {
|
||
this.ws.binaryType = 'arraybuffer';
|
||
}
|
||
|
||
this.addEventListeners();
|
||
};
|
||
|
||
/**
|
||
* Adds event listeners to the socket
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
WS.prototype.addEventListeners = function(){
|
||
var self = this;
|
||
|
||
this.ws.onopen = function(){
|
||
self.onOpen();
|
||
};
|
||
this.ws.onclose = function(){
|
||
self.onClose();
|
||
};
|
||
this.ws.onmessage = function(ev){
|
||
self.onData(ev.data);
|
||
};
|
||
this.ws.onerror = function(e){
|
||
self.onError('websocket error', e);
|
||
};
|
||
};
|
||
|
||
/**
|
||
* Override `onData` to use a timer on iOS.
|
||
* See: https://gist.github.com/mloughran/2052006
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
if ('undefined' != typeof navigator
|
||
&& /iPad|iPhone|iPod/i.test(navigator.userAgent)) {
|
||
WS.prototype.onData = function(data){
|
||
var self = this;
|
||
setTimeout(function(){
|
||
Transport.prototype.onData.call(self, data);
|
||
}, 0);
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Writes data to socket.
|
||
*
|
||
* @param {Array} array of packets.
|
||
* @api private
|
||
*/
|
||
|
||
WS.prototype.write = function(packets){
|
||
var self = this;
|
||
this.writable = false;
|
||
|
||
// encodePacket efficient as it uses WS framing
|
||
// no need for encodePayload
|
||
var total = packets.length;
|
||
for (var i = 0, l = total; i < l; i++) {
|
||
(function(packet) {
|
||
parser.encodePacket(packet, self.supportsBinary, function(data) {
|
||
if (!BrowserWebSocket) {
|
||
// always create a new object (GH-437)
|
||
var opts = {};
|
||
if (packet.options) {
|
||
opts.compress = packet.options.compress;
|
||
}
|
||
|
||
if (self.perMessageDeflate) {
|
||
var len = 'string' == typeof data ? global.Buffer.byteLength(data) : data.length;
|
||
if (len < self.perMessageDeflate.threshold) {
|
||
opts.compress = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
//Sometimes the websocket has already been closed but the browser didn't
|
||
//have a chance of informing us about it yet, in that case send will
|
||
//throw an error
|
||
try {
|
||
if (BrowserWebSocket) {
|
||
// TypeError is thrown when passing the second argument on Safari
|
||
self.ws.send(data);
|
||
} else {
|
||
self.ws.send(data, opts);
|
||
}
|
||
} catch (e){
|
||
debug('websocket closed before onclose event');
|
||
}
|
||
|
||
--total || done();
|
||
});
|
||
})(packets[i]);
|
||
}
|
||
|
||
function done(){
|
||
self.emit('flush');
|
||
|
||
// fake drain
|
||
// defer to next tick to allow Socket to clear writeBuffer
|
||
setTimeout(function(){
|
||
self.writable = true;
|
||
self.emit('drain');
|
||
}, 0);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Called upon close
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
WS.prototype.onClose = function(){
|
||
Transport.prototype.onClose.call(this);
|
||
};
|
||
|
||
/**
|
||
* Closes socket.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
WS.prototype.doClose = function(){
|
||
if (typeof this.ws !== 'undefined') {
|
||
this.ws.close();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Generates uri for connection.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
WS.prototype.uri = function(){
|
||
var query = this.query || {};
|
||
var schema = this.secure ? 'wss' : 'ws';
|
||
var port = '';
|
||
|
||
// avoid port if default for schema
|
||
if (this.port && (('wss' == schema && this.port != 443)
|
||
|| ('ws' == schema && this.port != 80))) {
|
||
port = ':' + this.port;
|
||
}
|
||
|
||
// append timestamp to URI
|
||
if (this.timestampRequests) {
|
||
query[this.timestampParam] = yeast();
|
||
}
|
||
|
||
// communicate binary support capabilities
|
||
if (!this.supportsBinary) {
|
||
query.b64 = 1;
|
||
}
|
||
|
||
query = parseqs.encode(query);
|
||
|
||
// prepend ? to query
|
||
if (query.length) {
|
||
query = '?' + query;
|
||
}
|
||
|
||
var ipv6 = this.hostname.indexOf(':') !== -1;
|
||
return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;
|
||
};
|
||
|
||
/**
|
||
* Feature detection for WebSocket.
|
||
*
|
||
* @return {Boolean} whether this transport is available.
|
||
* @api public
|
||
*/
|
||
|
||
WS.prototype.check = function(){
|
||
return !!WebSocket && !('__initialize' in WebSocket && this.name === WS.prototype.name);
|
||
};
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../transport":51,"component-inherit":15,"debug":46,"engine.io-parser":58,"parseqs":135,"ws":9,"yeast":154}],57:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/engine.io-client/lib/xmlhttprequest.js", module);
|
||
(function(){
|
||
// browser shim for xmlhttprequest module
|
||
var hasCORS = require('has-cors');
|
||
|
||
module.exports = function(opts) {
|
||
var xdomain = opts.xdomain;
|
||
|
||
// scheme must be same when usign XDomainRequest
|
||
// http://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx
|
||
var xscheme = opts.xscheme;
|
||
|
||
// XDomainRequest has a flow of not sending cookie, therefore it should be disabled as a default.
|
||
// https://github.com/Automattic/engine.io-client/pull/217
|
||
var enablesXDR = opts.enablesXDR;
|
||
|
||
// XMLHttpRequest can be disabled on IE
|
||
try {
|
||
if ('undefined' != typeof XMLHttpRequest && (!xdomain || hasCORS)) {
|
||
return new XMLHttpRequest();
|
||
}
|
||
} catch (e) { }
|
||
|
||
// Use XDomainRequest for IE8 if enablesXDR is true
|
||
// because loading bar keeps flashing when using jsonp-polling
|
||
// https://github.com/yujiosaka/socke.io-ie8-loading-example
|
||
try {
|
||
if ('undefined' != typeof XDomainRequest && !xscheme && enablesXDR) {
|
||
return new XDomainRequest();
|
||
}
|
||
} catch (e) { }
|
||
|
||
if (!xdomain) {
|
||
try {
|
||
return new ActiveXObject('Microsoft.XMLHTTP');
|
||
} catch(e) { }
|
||
}
|
||
}
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"has-cors":62}],58:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/engine.io-parser/lib/browser.js", module);
|
||
(function(){
|
||
(function (global){
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var keys = require('./keys');
|
||
var hasBinary = require('has-binary');
|
||
var sliceBuffer = require('arraybuffer.slice');
|
||
var base64encoder = require('base64-arraybuffer');
|
||
var after = require('after');
|
||
var utf8 = require('utf8');
|
||
|
||
/**
|
||
* Check if we are running an android browser. That requires us to use
|
||
* ArrayBuffer with polling transports...
|
||
*
|
||
* http://ghinda.net/jpeg-blob-ajax-android/
|
||
*/
|
||
|
||
var isAndroid = navigator.userAgent.match(/Android/i);
|
||
|
||
/**
|
||
* Check if we are running in PhantomJS.
|
||
* Uploading a Blob with PhantomJS does not work correctly, as reported here:
|
||
* https://github.com/ariya/phantomjs/issues/11395
|
||
* @type boolean
|
||
*/
|
||
var isPhantomJS = /PhantomJS/i.test(navigator.userAgent);
|
||
|
||
/**
|
||
* When true, avoids using Blobs to encode payloads.
|
||
* @type boolean
|
||
*/
|
||
var dontSendBlobs = isAndroid || isPhantomJS;
|
||
|
||
/**
|
||
* Current protocol version.
|
||
*/
|
||
|
||
exports.protocol = 3;
|
||
|
||
/**
|
||
* Packet types.
|
||
*/
|
||
|
||
var packets = exports.packets = {
|
||
open: 0 // non-ws
|
||
, close: 1 // non-ws
|
||
, ping: 2
|
||
, pong: 3
|
||
, message: 4
|
||
, upgrade: 5
|
||
, noop: 6
|
||
};
|
||
|
||
var packetslist = keys(packets);
|
||
|
||
/**
|
||
* Premade error packet.
|
||
*/
|
||
|
||
var err = { type: 'error', data: 'parser error' };
|
||
|
||
/**
|
||
* Create a blob api even for blob builder when vendor prefixes exist
|
||
*/
|
||
|
||
var Blob = require('blob');
|
||
|
||
/**
|
||
* Encodes a packet.
|
||
*
|
||
* <packet type id> [ <data> ]
|
||
*
|
||
* Example:
|
||
*
|
||
* 5hello world
|
||
* 3
|
||
* 4
|
||
*
|
||
* Binary is encoded in an identical principle
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
exports.encodePacket = function (packet, supportsBinary, utf8encode, callback) {
|
||
if ('function' == typeof supportsBinary) {
|
||
callback = supportsBinary;
|
||
supportsBinary = false;
|
||
}
|
||
|
||
if ('function' == typeof utf8encode) {
|
||
callback = utf8encode;
|
||
utf8encode = null;
|
||
}
|
||
|
||
var data = (packet.data === undefined)
|
||
? undefined
|
||
: packet.data.buffer || packet.data;
|
||
|
||
if (global.ArrayBuffer && data instanceof ArrayBuffer) {
|
||
return encodeArrayBuffer(packet, supportsBinary, callback);
|
||
} else if (Blob && data instanceof global.Blob) {
|
||
return encodeBlob(packet, supportsBinary, callback);
|
||
}
|
||
|
||
// might be an object with { base64: true, data: dataAsBase64String }
|
||
if (data && data.base64) {
|
||
return encodeBase64Object(packet, callback);
|
||
}
|
||
|
||
// Sending data as a utf-8 string
|
||
var encoded = packets[packet.type];
|
||
|
||
// data fragment is optional
|
||
if (undefined !== packet.data) {
|
||
encoded += utf8encode ? utf8.encode(String(packet.data)) : String(packet.data);
|
||
}
|
||
|
||
return callback('' + encoded);
|
||
|
||
};
|
||
|
||
function encodeBase64Object(packet, callback) {
|
||
// packet data is an object { base64: true, data: dataAsBase64String }
|
||
var message = 'b' + exports.packets[packet.type] + packet.data.data;
|
||
return callback(message);
|
||
}
|
||
|
||
/**
|
||
* Encode packet helpers for binary types
|
||
*/
|
||
|
||
function encodeArrayBuffer(packet, supportsBinary, callback) {
|
||
if (!supportsBinary) {
|
||
return exports.encodeBase64Packet(packet, callback);
|
||
}
|
||
|
||
var data = packet.data;
|
||
var contentArray = new Uint8Array(data);
|
||
var resultBuffer = new Uint8Array(1 + data.byteLength);
|
||
|
||
resultBuffer[0] = packets[packet.type];
|
||
for (var i = 0; i < contentArray.length; i++) {
|
||
resultBuffer[i+1] = contentArray[i];
|
||
}
|
||
|
||
return callback(resultBuffer.buffer);
|
||
}
|
||
|
||
function encodeBlobAsArrayBuffer(packet, supportsBinary, callback) {
|
||
if (!supportsBinary) {
|
||
return exports.encodeBase64Packet(packet, callback);
|
||
}
|
||
|
||
var fr = new FileReader();
|
||
fr.onload = function() {
|
||
packet.data = fr.result;
|
||
exports.encodePacket(packet, supportsBinary, true, callback);
|
||
};
|
||
return fr.readAsArrayBuffer(packet.data);
|
||
}
|
||
|
||
function encodeBlob(packet, supportsBinary, callback) {
|
||
if (!supportsBinary) {
|
||
return exports.encodeBase64Packet(packet, callback);
|
||
}
|
||
|
||
if (dontSendBlobs) {
|
||
return encodeBlobAsArrayBuffer(packet, supportsBinary, callback);
|
||
}
|
||
|
||
var length = new Uint8Array(1);
|
||
length[0] = packets[packet.type];
|
||
var blob = new Blob([length.buffer, packet.data]);
|
||
|
||
return callback(blob);
|
||
}
|
||
|
||
/**
|
||
* Encodes a packet with binary data in a base64 string
|
||
*
|
||
* @param {Object} packet, has `type` and `data`
|
||
* @return {String} base64 encoded message
|
||
*/
|
||
|
||
exports.encodeBase64Packet = function(packet, callback) {
|
||
var message = 'b' + exports.packets[packet.type];
|
||
if (Blob && packet.data instanceof global.Blob) {
|
||
var fr = new FileReader();
|
||
fr.onload = function() {
|
||
var b64 = fr.result.split(',')[1];
|
||
callback(message + b64);
|
||
};
|
||
return fr.readAsDataURL(packet.data);
|
||
}
|
||
|
||
var b64data;
|
||
try {
|
||
b64data = String.fromCharCode.apply(null, new Uint8Array(packet.data));
|
||
} catch (e) {
|
||
// iPhone Safari doesn't let you apply with typed arrays
|
||
var typed = new Uint8Array(packet.data);
|
||
var basic = new Array(typed.length);
|
||
for (var i = 0; i < typed.length; i++) {
|
||
basic[i] = typed[i];
|
||
}
|
||
b64data = String.fromCharCode.apply(null, basic);
|
||
}
|
||
message += global.btoa(b64data);
|
||
return callback(message);
|
||
};
|
||
|
||
/**
|
||
* Decodes a packet. Changes format to Blob if requested.
|
||
*
|
||
* @return {Object} with `type` and `data` (if any)
|
||
* @api private
|
||
*/
|
||
|
||
exports.decodePacket = function (data, binaryType, utf8decode) {
|
||
// String data
|
||
if (typeof data == 'string' || data === undefined) {
|
||
if (data.charAt(0) == 'b') {
|
||
return exports.decodeBase64Packet(data.substr(1), binaryType);
|
||
}
|
||
|
||
if (utf8decode) {
|
||
try {
|
||
data = utf8.decode(data);
|
||
} catch (e) {
|
||
return err;
|
||
}
|
||
}
|
||
var type = data.charAt(0);
|
||
|
||
if (Number(type) != type || !packetslist[type]) {
|
||
return err;
|
||
}
|
||
|
||
if (data.length > 1) {
|
||
return { type: packetslist[type], data: data.substring(1) };
|
||
} else {
|
||
return { type: packetslist[type] };
|
||
}
|
||
}
|
||
|
||
var asArray = new Uint8Array(data);
|
||
var type = asArray[0];
|
||
var rest = sliceBuffer(data, 1);
|
||
if (Blob && binaryType === 'blob') {
|
||
rest = new Blob([rest]);
|
||
}
|
||
return { type: packetslist[type], data: rest };
|
||
};
|
||
|
||
/**
|
||
* Decodes a packet encoded in a base64 string
|
||
*
|
||
* @param {String} base64 encoded message
|
||
* @return {Object} with `type` and `data` (if any)
|
||
*/
|
||
|
||
exports.decodeBase64Packet = function(msg, binaryType) {
|
||
var type = packetslist[msg.charAt(0)];
|
||
if (!global.ArrayBuffer) {
|
||
return { type: type, data: { base64: true, data: msg.substr(1) } };
|
||
}
|
||
|
||
var data = base64encoder.decode(msg.substr(1));
|
||
|
||
if (binaryType === 'blob' && Blob) {
|
||
data = new Blob([data]);
|
||
}
|
||
|
||
return { type: type, data: data };
|
||
};
|
||
|
||
/**
|
||
* Encodes multiple messages (payload).
|
||
*
|
||
* <length>:data
|
||
*
|
||
* Example:
|
||
*
|
||
* 11:hello world2:hi
|
||
*
|
||
* If any contents are binary, they will be encoded as base64 strings. Base64
|
||
* encoded strings are marked with a b before the length specifier
|
||
*
|
||
* @param {Array} packets
|
||
* @api private
|
||
*/
|
||
|
||
exports.encodePayload = function (packets, supportsBinary, callback) {
|
||
if (typeof supportsBinary == 'function') {
|
||
callback = supportsBinary;
|
||
supportsBinary = null;
|
||
}
|
||
|
||
var isBinary = hasBinary(packets);
|
||
|
||
if (supportsBinary && isBinary) {
|
||
if (Blob && !dontSendBlobs) {
|
||
return exports.encodePayloadAsBlob(packets, callback);
|
||
}
|
||
|
||
return exports.encodePayloadAsArrayBuffer(packets, callback);
|
||
}
|
||
|
||
if (!packets.length) {
|
||
return callback('0:');
|
||
}
|
||
|
||
function setLengthHeader(message) {
|
||
return message.length + ':' + message;
|
||
}
|
||
|
||
function encodeOne(packet, doneCallback) {
|
||
exports.encodePacket(packet, !isBinary ? false : supportsBinary, true, function(message) {
|
||
doneCallback(null, setLengthHeader(message));
|
||
});
|
||
}
|
||
|
||
map(packets, encodeOne, function(err, results) {
|
||
return callback(results.join(''));
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Async array map using after
|
||
*/
|
||
|
||
function map(ary, each, done) {
|
||
var result = new Array(ary.length);
|
||
var next = after(ary.length, done);
|
||
|
||
var eachWithIndex = function(i, el, cb) {
|
||
each(el, function(error, msg) {
|
||
result[i] = msg;
|
||
cb(error, result);
|
||
});
|
||
};
|
||
|
||
for (var i = 0; i < ary.length; i++) {
|
||
eachWithIndex(i, ary[i], next);
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Decodes data when a payload is maybe expected. Possible binary contents are
|
||
* decoded from their base64 representation
|
||
*
|
||
* @param {String} data, callback method
|
||
* @api public
|
||
*/
|
||
|
||
exports.decodePayload = function (data, binaryType, callback) {
|
||
if (typeof data != 'string') {
|
||
return exports.decodePayloadAsBinary(data, binaryType, callback);
|
||
}
|
||
|
||
if (typeof binaryType === 'function') {
|
||
callback = binaryType;
|
||
binaryType = null;
|
||
}
|
||
|
||
var packet;
|
||
if (data == '') {
|
||
// parser error - ignoring payload
|
||
return callback(err, 0, 1);
|
||
}
|
||
|
||
var length = ''
|
||
, n, msg;
|
||
|
||
for (var i = 0, l = data.length; i < l; i++) {
|
||
var chr = data.charAt(i);
|
||
|
||
if (':' != chr) {
|
||
length += chr;
|
||
} else {
|
||
if ('' == length || (length != (n = Number(length)))) {
|
||
// parser error - ignoring payload
|
||
return callback(err, 0, 1);
|
||
}
|
||
|
||
msg = data.substr(i + 1, n);
|
||
|
||
if (length != msg.length) {
|
||
// parser error - ignoring payload
|
||
return callback(err, 0, 1);
|
||
}
|
||
|
||
if (msg.length) {
|
||
packet = exports.decodePacket(msg, binaryType, true);
|
||
|
||
if (err.type == packet.type && err.data == packet.data) {
|
||
// parser error in individual packet - ignoring payload
|
||
return callback(err, 0, 1);
|
||
}
|
||
|
||
var ret = callback(packet, i + n, l);
|
||
if (false === ret) return;
|
||
}
|
||
|
||
// advance cursor
|
||
i += n;
|
||
length = '';
|
||
}
|
||
}
|
||
|
||
if (length != '') {
|
||
// parser error - ignoring payload
|
||
return callback(err, 0, 1);
|
||
}
|
||
|
||
};
|
||
|
||
/**
|
||
* Encodes multiple messages (payload) as binary.
|
||
*
|
||
* <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number
|
||
* 255><data>
|
||
*
|
||
* Example:
|
||
* 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers
|
||
*
|
||
* @param {Array} packets
|
||
* @return {ArrayBuffer} encoded payload
|
||
* @api private
|
||
*/
|
||
|
||
exports.encodePayloadAsArrayBuffer = function(packets, callback) {
|
||
if (!packets.length) {
|
||
return callback(new ArrayBuffer(0));
|
||
}
|
||
|
||
function encodeOne(packet, doneCallback) {
|
||
exports.encodePacket(packet, true, true, function(data) {
|
||
return doneCallback(null, data);
|
||
});
|
||
}
|
||
|
||
map(packets, encodeOne, function(err, encodedPackets) {
|
||
var totalLength = encodedPackets.reduce(function(acc, p) {
|
||
var len;
|
||
if (typeof p === 'string'){
|
||
len = p.length;
|
||
} else {
|
||
len = p.byteLength;
|
||
}
|
||
return acc + len.toString().length + len + 2; // string/binary identifier + separator = 2
|
||
}, 0);
|
||
|
||
var resultArray = new Uint8Array(totalLength);
|
||
|
||
var bufferIndex = 0;
|
||
encodedPackets.forEach(function(p) {
|
||
var isString = typeof p === 'string';
|
||
var ab = p;
|
||
if (isString) {
|
||
var view = new Uint8Array(p.length);
|
||
for (var i = 0; i < p.length; i++) {
|
||
view[i] = p.charCodeAt(i);
|
||
}
|
||
ab = view.buffer;
|
||
}
|
||
|
||
if (isString) { // not true binary
|
||
resultArray[bufferIndex++] = 0;
|
||
} else { // true binary
|
||
resultArray[bufferIndex++] = 1;
|
||
}
|
||
|
||
var lenStr = ab.byteLength.toString();
|
||
for (var i = 0; i < lenStr.length; i++) {
|
||
resultArray[bufferIndex++] = parseInt(lenStr[i]);
|
||
}
|
||
resultArray[bufferIndex++] = 255;
|
||
|
||
var view = new Uint8Array(ab);
|
||
for (var i = 0; i < view.length; i++) {
|
||
resultArray[bufferIndex++] = view[i];
|
||
}
|
||
});
|
||
|
||
return callback(resultArray.buffer);
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Encode as Blob
|
||
*/
|
||
|
||
exports.encodePayloadAsBlob = function(packets, callback) {
|
||
function encodeOne(packet, doneCallback) {
|
||
exports.encodePacket(packet, true, true, function(encoded) {
|
||
var binaryIdentifier = new Uint8Array(1);
|
||
binaryIdentifier[0] = 1;
|
||
if (typeof encoded === 'string') {
|
||
var view = new Uint8Array(encoded.length);
|
||
for (var i = 0; i < encoded.length; i++) {
|
||
view[i] = encoded.charCodeAt(i);
|
||
}
|
||
encoded = view.buffer;
|
||
binaryIdentifier[0] = 0;
|
||
}
|
||
|
||
var len = (encoded instanceof ArrayBuffer)
|
||
? encoded.byteLength
|
||
: encoded.size;
|
||
|
||
var lenStr = len.toString();
|
||
var lengthAry = new Uint8Array(lenStr.length + 1);
|
||
for (var i = 0; i < lenStr.length; i++) {
|
||
lengthAry[i] = parseInt(lenStr[i]);
|
||
}
|
||
lengthAry[lenStr.length] = 255;
|
||
|
||
if (Blob) {
|
||
var blob = new Blob([binaryIdentifier.buffer, lengthAry.buffer, encoded]);
|
||
doneCallback(null, blob);
|
||
}
|
||
});
|
||
}
|
||
|
||
map(packets, encodeOne, function(err, results) {
|
||
return callback(new Blob(results));
|
||
});
|
||
};
|
||
|
||
/*
|
||
* Decodes data when a payload is maybe expected. Strings are decoded by
|
||
* interpreting each byte as a key code for entries marked to start with 0. See
|
||
* description of encodePayloadAsBinary
|
||
*
|
||
* @param {ArrayBuffer} data, callback method
|
||
* @api public
|
||
*/
|
||
|
||
exports.decodePayloadAsBinary = function (data, binaryType, callback) {
|
||
if (typeof binaryType === 'function') {
|
||
callback = binaryType;
|
||
binaryType = null;
|
||
}
|
||
|
||
var bufferTail = data;
|
||
var buffers = [];
|
||
|
||
var numberTooLong = false;
|
||
while (bufferTail.byteLength > 0) {
|
||
var tailArray = new Uint8Array(bufferTail);
|
||
var isString = tailArray[0] === 0;
|
||
var msgLength = '';
|
||
|
||
for (var i = 1; ; i++) {
|
||
if (tailArray[i] == 255) break;
|
||
|
||
if (msgLength.length > 310) {
|
||
numberTooLong = true;
|
||
break;
|
||
}
|
||
|
||
msgLength += tailArray[i];
|
||
}
|
||
|
||
if(numberTooLong) return callback(err, 0, 1);
|
||
|
||
bufferTail = sliceBuffer(bufferTail, 2 + msgLength.length);
|
||
msgLength = parseInt(msgLength);
|
||
|
||
var msg = sliceBuffer(bufferTail, 0, msgLength);
|
||
if (isString) {
|
||
try {
|
||
msg = String.fromCharCode.apply(null, new Uint8Array(msg));
|
||
} catch (e) {
|
||
// iPhone Safari doesn't let you apply to typed arrays
|
||
var typed = new Uint8Array(msg);
|
||
msg = '';
|
||
for (var i = 0; i < typed.length; i++) {
|
||
msg += String.fromCharCode(typed[i]);
|
||
}
|
||
}
|
||
}
|
||
|
||
buffers.push(msg);
|
||
bufferTail = sliceBuffer(bufferTail, msgLength);
|
||
}
|
||
|
||
var total = buffers.length;
|
||
buffers.forEach(function(buffer, i) {
|
||
callback(exports.decodePacket(buffer, binaryType, true), i, total);
|
||
});
|
||
};
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./keys":59,"after":2,"arraybuffer.slice":3,"base64-arraybuffer":7,"blob":8,"has-binary":60,"utf8":149}],59:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/engine.io-parser/lib/keys.js", module);
|
||
(function(){
|
||
|
||
/**
|
||
* Gets the keys for an object.
|
||
*
|
||
* @return {Array} keys
|
||
* @api private
|
||
*/
|
||
|
||
module.exports = Object.keys || function keys (obj){
|
||
var arr = [];
|
||
var has = Object.prototype.hasOwnProperty;
|
||
|
||
for (var i in obj) {
|
||
if (has.call(obj, i)) {
|
||
arr.push(i);
|
||
}
|
||
}
|
||
return arr;
|
||
};
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],60:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/engine.io-parser/node_modules/has-binary/index.js", module);
|
||
(function(){
|
||
(function (global){
|
||
|
||
/*
|
||
* Module requirements.
|
||
*/
|
||
|
||
var isArray = require('isarray');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = hasBinary;
|
||
|
||
/**
|
||
* Checks for binary data.
|
||
*
|
||
* Right now only Buffer and ArrayBuffer are supported..
|
||
*
|
||
* @param {Object} anything
|
||
* @api public
|
||
*/
|
||
|
||
function hasBinary(data) {
|
||
|
||
function _hasBinary(obj) {
|
||
if (!obj) return false;
|
||
|
||
if ( (global.Buffer && global.Buffer.isBuffer(obj)) ||
|
||
(global.ArrayBuffer && obj instanceof ArrayBuffer) ||
|
||
(global.Blob && obj instanceof Blob) ||
|
||
(global.File && obj instanceof File)
|
||
) {
|
||
return true;
|
||
}
|
||
|
||
if (isArray(obj)) {
|
||
for (var i = 0; i < obj.length; i++) {
|
||
if (_hasBinary(obj[i])) {
|
||
return true;
|
||
}
|
||
}
|
||
} else if (obj && 'object' == typeof obj) {
|
||
if (obj.toJSON) {
|
||
obj = obj.toJSON();
|
||
}
|
||
|
||
for (var key in obj) {
|
||
if (Object.prototype.hasOwnProperty.call(obj, key) && _hasBinary(obj[key])) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
return _hasBinary(data);
|
||
}
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"isarray":64}],61:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/has-binary/index.js", module);
|
||
(function(){
|
||
(function (global){
|
||
|
||
/*
|
||
* Module requirements.
|
||
*/
|
||
|
||
var isArray = require('isarray');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = hasBinary;
|
||
|
||
/**
|
||
* Checks for binary data.
|
||
*
|
||
* Right now only Buffer and ArrayBuffer are supported..
|
||
*
|
||
* @param {Object} anything
|
||
* @api public
|
||
*/
|
||
|
||
function hasBinary(data) {
|
||
|
||
function _hasBinary(obj) {
|
||
if (!obj) return false;
|
||
|
||
if ( (global.Buffer && global.Buffer.isBuffer && global.Buffer.isBuffer(obj)) ||
|
||
(global.ArrayBuffer && obj instanceof ArrayBuffer) ||
|
||
(global.Blob && obj instanceof Blob) ||
|
||
(global.File && obj instanceof File)
|
||
) {
|
||
return true;
|
||
}
|
||
|
||
if (isArray(obj)) {
|
||
for (var i = 0; i < obj.length; i++) {
|
||
if (_hasBinary(obj[i])) {
|
||
return true;
|
||
}
|
||
}
|
||
} else if (obj && 'object' == typeof obj) {
|
||
// see: https://github.com/Automattic/has-binary/pull/4
|
||
if (obj.toJSON && 'function' == typeof obj.toJSON) {
|
||
obj = obj.toJSON();
|
||
}
|
||
|
||
for (var key in obj) {
|
||
if (Object.prototype.hasOwnProperty.call(obj, key) && _hasBinary(obj[key])) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
return _hasBinary(data);
|
||
}
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"isarray":64}],62:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/has-cors/index.js", module);
|
||
(function(){
|
||
|
||
/**
|
||
* Module exports.
|
||
*
|
||
* Logic borrowed from Modernizr:
|
||
*
|
||
* - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cors.js
|
||
*/
|
||
|
||
try {
|
||
module.exports = typeof XMLHttpRequest !== 'undefined' &&
|
||
'withCredentials' in new XMLHttpRequest();
|
||
} catch (err) {
|
||
// if XMLHttp support is disabled in IE then it will throw
|
||
// when trying to create
|
||
module.exports = false;
|
||
}
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],63:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/indexof/index.js", module);
|
||
(function(){
|
||
|
||
var indexOf = [].indexOf;
|
||
|
||
module.exports = function(arr, obj){
|
||
if (indexOf) return arr.indexOf(obj);
|
||
for (var i = 0; i < arr.length; ++i) {
|
||
if (arr[i] === obj) return i;
|
||
}
|
||
return -1;
|
||
};
|
||
}).apply(this, arguments);
|
||
|
||
},{}],64:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/isarray/index.js", module);
|
||
(function(){
|
||
module.exports = Array.isArray || function (arr) {
|
||
return Object.prototype.toString.call(arr) == '[object Array]';
|
||
};
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],65:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/array/last.js", module);
|
||
(function(){
|
||
/**
|
||
* Gets the last element of `array`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Array
|
||
* @param {Array} array The array to query.
|
||
* @returns {*} Returns the last element of `array`.
|
||
* @example
|
||
*
|
||
* _.last([1, 2, 3]);
|
||
* // => 3
|
||
*/
|
||
function last(array) {
|
||
var length = array ? array.length : 0;
|
||
return length ? array[length - 1] : undefined;
|
||
}
|
||
|
||
module.exports = last;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],66:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/array/zipObject.js", module);
|
||
(function(){
|
||
var isArray = require('../lang/isArray');
|
||
|
||
/**
|
||
* The inverse of `_.pairs`; this method returns an object composed from arrays
|
||
* of property names and values. Provide either a single two dimensional array,
|
||
* e.g. `[[key1, value1], [key2, value2]]` or two arrays, one of property names
|
||
* and one of corresponding values.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @alias object
|
||
* @category Array
|
||
* @param {Array} props The property names.
|
||
* @param {Array} [values=[]] The property values.
|
||
* @returns {Object} Returns the new object.
|
||
* @example
|
||
*
|
||
* _.zipObject([['fred', 30], ['barney', 40]]);
|
||
* // => { 'fred': 30, 'barney': 40 }
|
||
*
|
||
* _.zipObject(['fred', 'barney'], [30, 40]);
|
||
* // => { 'fred': 30, 'barney': 40 }
|
||
*/
|
||
function zipObject(props, values) {
|
||
var index = -1,
|
||
length = props ? props.length : 0,
|
||
result = {};
|
||
|
||
if (length && !values && !isArray(props[0])) {
|
||
values = [];
|
||
}
|
||
while (++index < length) {
|
||
var key = props[index];
|
||
if (values) {
|
||
result[key] = values[index];
|
||
} else if (key) {
|
||
result[key[0]] = key[1];
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = zipObject;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../lang/isArray":120}],67:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/collection/filter.js", module);
|
||
(function(){
|
||
var arrayFilter = require('../internal/arrayFilter'),
|
||
baseCallback = require('../internal/baseCallback'),
|
||
baseFilter = require('../internal/baseFilter'),
|
||
isArray = require('../lang/isArray');
|
||
|
||
/**
|
||
* Iterates over elements of `collection`, returning an array of all elements
|
||
* `predicate` returns truthy for. The predicate is bound to `thisArg` and
|
||
* invoked with three arguments: (value, index|key, collection).
|
||
*
|
||
* If a property name is provided for `predicate` the created `_.property`
|
||
* style callback returns the property value of the given element.
|
||
*
|
||
* If a value is also provided for `thisArg` the created `_.matchesProperty`
|
||
* style callback returns `true` for elements that have a matching property
|
||
* value, else `false`.
|
||
*
|
||
* If an object is provided for `predicate` the created `_.matches` style
|
||
* callback returns `true` for elements that have the properties of the given
|
||
* object, else `false`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @alias select
|
||
* @category Collection
|
||
* @param {Array|Object|string} collection The collection to iterate over.
|
||
* @param {Function|Object|string} [predicate=_.identity] The function invoked
|
||
* per iteration.
|
||
* @param {*} [thisArg] The `this` binding of `predicate`.
|
||
* @returns {Array} Returns the new filtered array.
|
||
* @example
|
||
*
|
||
* _.filter([4, 5, 6], function(n) {
|
||
* return n % 2 == 0;
|
||
* });
|
||
* // => [4, 6]
|
||
*
|
||
* var users = [
|
||
* { 'user': 'barney', 'age': 36, 'active': true },
|
||
* { 'user': 'fred', 'age': 40, 'active': false }
|
||
* ];
|
||
*
|
||
* // using the `_.matches` callback shorthand
|
||
* _.pluck(_.filter(users, { 'age': 36, 'active': true }), 'user');
|
||
* // => ['barney']
|
||
*
|
||
* // using the `_.matchesProperty` callback shorthand
|
||
* _.pluck(_.filter(users, 'active', false), 'user');
|
||
* // => ['fred']
|
||
*
|
||
* // using the `_.property` callback shorthand
|
||
* _.pluck(_.filter(users, 'active'), 'user');
|
||
* // => ['barney']
|
||
*/
|
||
function filter(collection, predicate, thisArg) {
|
||
var func = isArray(collection) ? arrayFilter : baseFilter;
|
||
predicate = baseCallback(predicate, thisArg, 3);
|
||
return func(collection, predicate);
|
||
}
|
||
|
||
module.exports = filter;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/arrayFilter":73,"../internal/baseCallback":78,"../internal/baseFilter":81,"../lang/isArray":120}],68:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/collection/forEach.js", module);
|
||
(function(){
|
||
var arrayEach = require('../internal/arrayEach'),
|
||
baseEach = require('../internal/baseEach'),
|
||
createForEach = require('../internal/createForEach');
|
||
|
||
/**
|
||
* Iterates over elements of `collection` invoking `iteratee` for each element.
|
||
* The `iteratee` is bound to `thisArg` and invoked with three arguments:
|
||
* (value, index|key, collection). Iteratee functions may exit iteration early
|
||
* by explicitly returning `false`.
|
||
*
|
||
* **Note:** As with other "Collections" methods, objects with a "length" property
|
||
* are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn`
|
||
* may be used for object iteration.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @alias each
|
||
* @category Collection
|
||
* @param {Array|Object|string} collection The collection to iterate over.
|
||
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
|
||
* @param {*} [thisArg] The `this` binding of `iteratee`.
|
||
* @returns {Array|Object|string} Returns `collection`.
|
||
* @example
|
||
*
|
||
* _([1, 2]).forEach(function(n) {
|
||
* console.log(n);
|
||
* }).value();
|
||
* // => logs each value from left to right and returns the array
|
||
*
|
||
* _.forEach({ 'a': 1, 'b': 2 }, function(n, key) {
|
||
* console.log(n, key);
|
||
* });
|
||
* // => logs each value-key pair and returns the object (iteration order is not guaranteed)
|
||
*/
|
||
var forEach = createForEach(arrayEach, baseEach);
|
||
|
||
module.exports = forEach;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/arrayEach":72,"../internal/baseEach":80,"../internal/createForEach":100}],69:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/collection/map.js", module);
|
||
(function(){
|
||
var arrayMap = require('../internal/arrayMap'),
|
||
baseCallback = require('../internal/baseCallback'),
|
||
baseMap = require('../internal/baseMap'),
|
||
isArray = require('../lang/isArray');
|
||
|
||
/**
|
||
* Creates an array of values by running each element in `collection` through
|
||
* `iteratee`. The `iteratee` is bound to `thisArg` and invoked with three
|
||
* arguments: (value, index|key, collection).
|
||
*
|
||
* If a property name is provided for `iteratee` the created `_.property`
|
||
* style callback returns the property value of the given element.
|
||
*
|
||
* If a value is also provided for `thisArg` the created `_.matchesProperty`
|
||
* style callback returns `true` for elements that have a matching property
|
||
* value, else `false`.
|
||
*
|
||
* If an object is provided for `iteratee` the created `_.matches` style
|
||
* callback returns `true` for elements that have the properties of the given
|
||
* object, else `false`.
|
||
*
|
||
* Many lodash methods are guarded to work as iteratees for methods like
|
||
* `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
|
||
*
|
||
* The guarded methods are:
|
||
* `ary`, `callback`, `chunk`, `clone`, `create`, `curry`, `curryRight`,
|
||
* `drop`, `dropRight`, `every`, `fill`, `flatten`, `invert`, `max`, `min`,
|
||
* `parseInt`, `slice`, `sortBy`, `take`, `takeRight`, `template`, `trim`,
|
||
* `trimLeft`, `trimRight`, `trunc`, `random`, `range`, `sample`, `some`,
|
||
* `sum`, `uniq`, and `words`
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @alias collect
|
||
* @category Collection
|
||
* @param {Array|Object|string} collection The collection to iterate over.
|
||
* @param {Function|Object|string} [iteratee=_.identity] The function invoked
|
||
* per iteration.
|
||
* @param {*} [thisArg] The `this` binding of `iteratee`.
|
||
* @returns {Array} Returns the new mapped array.
|
||
* @example
|
||
*
|
||
* function timesThree(n) {
|
||
* return n * 3;
|
||
* }
|
||
*
|
||
* _.map([1, 2], timesThree);
|
||
* // => [3, 6]
|
||
*
|
||
* _.map({ 'a': 1, 'b': 2 }, timesThree);
|
||
* // => [3, 6] (iteration order is not guaranteed)
|
||
*
|
||
* var users = [
|
||
* { 'user': 'barney' },
|
||
* { 'user': 'fred' }
|
||
* ];
|
||
*
|
||
* // using the `_.property` callback shorthand
|
||
* _.map(users, 'user');
|
||
* // => ['barney', 'fred']
|
||
*/
|
||
function map(collection, iteratee, thisArg) {
|
||
var func = isArray(collection) ? arrayMap : baseMap;
|
||
iteratee = baseCallback(iteratee, thisArg, 3);
|
||
return func(collection, iteratee);
|
||
}
|
||
|
||
module.exports = map;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/arrayMap":74,"../internal/baseCallback":78,"../internal/baseMap":88,"../lang/isArray":120}],70:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/collection/some.js", module);
|
||
(function(){
|
||
var arraySome = require('../internal/arraySome'),
|
||
baseCallback = require('../internal/baseCallback'),
|
||
baseSome = require('../internal/baseSome'),
|
||
isArray = require('../lang/isArray'),
|
||
isIterateeCall = require('../internal/isIterateeCall');
|
||
|
||
/**
|
||
* Checks if `predicate` returns truthy for **any** element of `collection`.
|
||
* The function returns as soon as it finds a passing value and does not iterate
|
||
* over the entire collection. The predicate is bound to `thisArg` and invoked
|
||
* with three arguments: (value, index|key, collection).
|
||
*
|
||
* If a property name is provided for `predicate` the created `_.property`
|
||
* style callback returns the property value of the given element.
|
||
*
|
||
* If a value is also provided for `thisArg` the created `_.matchesProperty`
|
||
* style callback returns `true` for elements that have a matching property
|
||
* value, else `false`.
|
||
*
|
||
* If an object is provided for `predicate` the created `_.matches` style
|
||
* callback returns `true` for elements that have the properties of the given
|
||
* object, else `false`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @alias any
|
||
* @category Collection
|
||
* @param {Array|Object|string} collection The collection to iterate over.
|
||
* @param {Function|Object|string} [predicate=_.identity] The function invoked
|
||
* per iteration.
|
||
* @param {*} [thisArg] The `this` binding of `predicate`.
|
||
* @returns {boolean} Returns `true` if any element passes the predicate check,
|
||
* else `false`.
|
||
* @example
|
||
*
|
||
* _.some([null, 0, 'yes', false], Boolean);
|
||
* // => true
|
||
*
|
||
* var users = [
|
||
* { 'user': 'barney', 'active': true },
|
||
* { 'user': 'fred', 'active': false }
|
||
* ];
|
||
*
|
||
* // using the `_.matches` callback shorthand
|
||
* _.some(users, { 'user': 'barney', 'active': false });
|
||
* // => false
|
||
*
|
||
* // using the `_.matchesProperty` callback shorthand
|
||
* _.some(users, 'active', false);
|
||
* // => true
|
||
*
|
||
* // using the `_.property` callback shorthand
|
||
* _.some(users, 'active');
|
||
* // => true
|
||
*/
|
||
function some(collection, predicate, thisArg) {
|
||
var func = isArray(collection) ? arraySome : baseSome;
|
||
if (thisArg && isIterateeCall(collection, predicate, thisArg)) {
|
||
predicate = undefined;
|
||
}
|
||
if (typeof predicate != 'function' || thisArg !== undefined) {
|
||
predicate = baseCallback(predicate, thisArg, 3);
|
||
}
|
||
return func(collection, predicate);
|
||
}
|
||
|
||
module.exports = some;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/arraySome":75,"../internal/baseCallback":78,"../internal/baseSome":94,"../internal/isIterateeCall":111,"../lang/isArray":120}],71:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/function/restParam.js", module);
|
||
(function(){
|
||
/** Used as the `TypeError` message for "Functions" methods. */
|
||
var FUNC_ERROR_TEXT = 'Expected a function';
|
||
|
||
/* Native method references for those with the same name as other `lodash` methods. */
|
||
var nativeMax = Math.max;
|
||
|
||
/**
|
||
* Creates a function that invokes `func` with the `this` binding of the
|
||
* created function and arguments from `start` and beyond provided as an array.
|
||
*
|
||
* **Note:** This method is based on the [rest parameter](https://developer.mozilla.org/Web/JavaScript/Reference/Functions/rest_parameters).
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Function
|
||
* @param {Function} func The function to apply a rest parameter to.
|
||
* @param {number} [start=func.length-1] The start position of the rest parameter.
|
||
* @returns {Function} Returns the new function.
|
||
* @example
|
||
*
|
||
* var say = _.restParam(function(what, names) {
|
||
* return what + ' ' + _.initial(names).join(', ') +
|
||
* (_.size(names) > 1 ? ', & ' : '') + _.last(names);
|
||
* });
|
||
*
|
||
* say('hello', 'fred', 'barney', 'pebbles');
|
||
* // => 'hello fred, barney, & pebbles'
|
||
*/
|
||
function restParam(func, start) {
|
||
if (typeof func != 'function') {
|
||
throw new TypeError(FUNC_ERROR_TEXT);
|
||
}
|
||
start = nativeMax(start === undefined ? (func.length - 1) : (+start || 0), 0);
|
||
return function() {
|
||
var args = arguments,
|
||
index = -1,
|
||
length = nativeMax(args.length - start, 0),
|
||
rest = Array(length);
|
||
|
||
while (++index < length) {
|
||
rest[index] = args[start + index];
|
||
}
|
||
switch (start) {
|
||
case 0: return func.call(this, rest);
|
||
case 1: return func.call(this, args[0], rest);
|
||
case 2: return func.call(this, args[0], args[1], rest);
|
||
}
|
||
var otherArgs = Array(start + 1);
|
||
index = -1;
|
||
while (++index < start) {
|
||
otherArgs[index] = args[index];
|
||
}
|
||
otherArgs[start] = rest;
|
||
return func.apply(this, otherArgs);
|
||
};
|
||
}
|
||
|
||
module.exports = restParam;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],72:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/arrayEach.js", module);
|
||
(function(){
|
||
/**
|
||
* A specialized version of `_.forEach` for arrays without support for callback
|
||
* shorthands and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Array} array The array to iterate over.
|
||
* @param {Function} iteratee The function invoked per iteration.
|
||
* @returns {Array} Returns `array`.
|
||
*/
|
||
function arrayEach(array, iteratee) {
|
||
var index = -1,
|
||
length = array.length;
|
||
|
||
while (++index < length) {
|
||
if (iteratee(array[index], index, array) === false) {
|
||
break;
|
||
}
|
||
}
|
||
return array;
|
||
}
|
||
|
||
module.exports = arrayEach;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],73:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/arrayFilter.js", module);
|
||
(function(){
|
||
/**
|
||
* A specialized version of `_.filter` for arrays without support for callback
|
||
* shorthands and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Array} array The array to iterate over.
|
||
* @param {Function} predicate The function invoked per iteration.
|
||
* @returns {Array} Returns the new filtered array.
|
||
*/
|
||
function arrayFilter(array, predicate) {
|
||
var index = -1,
|
||
length = array.length,
|
||
resIndex = -1,
|
||
result = [];
|
||
|
||
while (++index < length) {
|
||
var value = array[index];
|
||
if (predicate(value, index, array)) {
|
||
result[++resIndex] = value;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = arrayFilter;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],74:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/arrayMap.js", module);
|
||
(function(){
|
||
/**
|
||
* A specialized version of `_.map` for arrays without support for callback
|
||
* shorthands and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Array} array The array to iterate over.
|
||
* @param {Function} iteratee The function invoked per iteration.
|
||
* @returns {Array} Returns the new mapped array.
|
||
*/
|
||
function arrayMap(array, iteratee) {
|
||
var index = -1,
|
||
length = array.length,
|
||
result = Array(length);
|
||
|
||
while (++index < length) {
|
||
result[index] = iteratee(array[index], index, array);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = arrayMap;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],75:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/arraySome.js", module);
|
||
(function(){
|
||
/**
|
||
* A specialized version of `_.some` for arrays without support for callback
|
||
* shorthands and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Array} array The array to iterate over.
|
||
* @param {Function} predicate The function invoked per iteration.
|
||
* @returns {boolean} Returns `true` if any element passes the predicate check,
|
||
* else `false`.
|
||
*/
|
||
function arraySome(array, predicate) {
|
||
var index = -1,
|
||
length = array.length;
|
||
|
||
while (++index < length) {
|
||
if (predicate(array[index], index, array)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
module.exports = arraySome;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],76:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/assignWith.js", module);
|
||
(function(){
|
||
var keys = require('../object/keys');
|
||
|
||
/**
|
||
* A specialized version of `_.assign` for customizing assigned values without
|
||
* support for argument juggling, multiple sources, and `this` binding `customizer`
|
||
* functions.
|
||
*
|
||
* @private
|
||
* @param {Object} object The destination object.
|
||
* @param {Object} source The source object.
|
||
* @param {Function} customizer The function to customize assigned values.
|
||
* @returns {Object} Returns `object`.
|
||
*/
|
||
function assignWith(object, source, customizer) {
|
||
var index = -1,
|
||
props = keys(source),
|
||
length = props.length;
|
||
|
||
while (++index < length) {
|
||
var key = props[index],
|
||
value = object[key],
|
||
result = customizer(value, source[key], key, object, source);
|
||
|
||
if ((result === result ? (result !== value) : (value === value)) ||
|
||
(value === undefined && !(key in object))) {
|
||
object[key] = result;
|
||
}
|
||
}
|
||
return object;
|
||
}
|
||
|
||
module.exports = assignWith;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../object/keys":127}],77:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseAssign.js", module);
|
||
(function(){
|
||
var baseCopy = require('./baseCopy'),
|
||
keys = require('../object/keys');
|
||
|
||
/**
|
||
* The base implementation of `_.assign` without support for argument juggling,
|
||
* multiple sources, and `customizer` functions.
|
||
*
|
||
* @private
|
||
* @param {Object} object The destination object.
|
||
* @param {Object} source The source object.
|
||
* @returns {Object} Returns `object`.
|
||
*/
|
||
function baseAssign(object, source) {
|
||
return source == null
|
||
? object
|
||
: baseCopy(source, keys(source), object);
|
||
}
|
||
|
||
module.exports = baseAssign;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../object/keys":127,"./baseCopy":79}],78:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseCallback.js", module);
|
||
(function(){
|
||
var baseMatches = require('./baseMatches'),
|
||
baseMatchesProperty = require('./baseMatchesProperty'),
|
||
bindCallback = require('./bindCallback'),
|
||
identity = require('../utility/identity'),
|
||
property = require('../utility/property');
|
||
|
||
/**
|
||
* The base implementation of `_.callback` which supports specifying the
|
||
* number of arguments to provide to `func`.
|
||
*
|
||
* @private
|
||
* @param {*} [func=_.identity] The value to convert to a callback.
|
||
* @param {*} [thisArg] The `this` binding of `func`.
|
||
* @param {number} [argCount] The number of arguments to provide to `func`.
|
||
* @returns {Function} Returns the callback.
|
||
*/
|
||
function baseCallback(func, thisArg, argCount) {
|
||
var type = typeof func;
|
||
if (type == 'function') {
|
||
return thisArg === undefined
|
||
? func
|
||
: bindCallback(func, thisArg, argCount);
|
||
}
|
||
if (func == null) {
|
||
return identity;
|
||
}
|
||
if (type == 'object') {
|
||
return baseMatches(func);
|
||
}
|
||
return thisArg === undefined
|
||
? property(func)
|
||
: baseMatchesProperty(func, thisArg);
|
||
}
|
||
|
||
module.exports = baseCallback;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../utility/identity":131,"../utility/property":132,"./baseMatches":89,"./baseMatchesProperty":90,"./bindCallback":96}],79:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseCopy.js", module);
|
||
(function(){
|
||
/**
|
||
* Copies properties of `source` to `object`.
|
||
*
|
||
* @private
|
||
* @param {Object} source The object to copy properties from.
|
||
* @param {Array} props The property names to copy.
|
||
* @param {Object} [object={}] The object to copy properties to.
|
||
* @returns {Object} Returns `object`.
|
||
*/
|
||
function baseCopy(source, props, object) {
|
||
object || (object = {});
|
||
|
||
var index = -1,
|
||
length = props.length;
|
||
|
||
while (++index < length) {
|
||
var key = props[index];
|
||
object[key] = source[key];
|
||
}
|
||
return object;
|
||
}
|
||
|
||
module.exports = baseCopy;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],80:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseEach.js", module);
|
||
(function(){
|
||
var baseForOwn = require('./baseForOwn'),
|
||
createBaseEach = require('./createBaseEach');
|
||
|
||
/**
|
||
* The base implementation of `_.forEach` without support for callback
|
||
* shorthands and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Array|Object|string} collection The collection to iterate over.
|
||
* @param {Function} iteratee The function invoked per iteration.
|
||
* @returns {Array|Object|string} Returns `collection`.
|
||
*/
|
||
var baseEach = createBaseEach(baseForOwn);
|
||
|
||
module.exports = baseEach;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./baseForOwn":83,"./createBaseEach":98}],81:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseFilter.js", module);
|
||
(function(){
|
||
var baseEach = require('./baseEach');
|
||
|
||
/**
|
||
* The base implementation of `_.filter` without support for callback
|
||
* shorthands and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Array|Object|string} collection The collection to iterate over.
|
||
* @param {Function} predicate The function invoked per iteration.
|
||
* @returns {Array} Returns the new filtered array.
|
||
*/
|
||
function baseFilter(collection, predicate) {
|
||
var result = [];
|
||
baseEach(collection, function(value, index, collection) {
|
||
if (predicate(value, index, collection)) {
|
||
result.push(value);
|
||
}
|
||
});
|
||
return result;
|
||
}
|
||
|
||
module.exports = baseFilter;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./baseEach":80}],82:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseFor.js", module);
|
||
(function(){
|
||
var createBaseFor = require('./createBaseFor');
|
||
|
||
/**
|
||
* The base implementation of `baseForIn` and `baseForOwn` which iterates
|
||
* over `object` properties returned by `keysFunc` invoking `iteratee` for
|
||
* each property. Iteratee functions may exit iteration early by explicitly
|
||
* returning `false`.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to iterate over.
|
||
* @param {Function} iteratee The function invoked per iteration.
|
||
* @param {Function} keysFunc The function to get the keys of `object`.
|
||
* @returns {Object} Returns `object`.
|
||
*/
|
||
var baseFor = createBaseFor();
|
||
|
||
module.exports = baseFor;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./createBaseFor":99}],83:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseForOwn.js", module);
|
||
(function(){
|
||
var baseFor = require('./baseFor'),
|
||
keys = require('../object/keys');
|
||
|
||
/**
|
||
* The base implementation of `_.forOwn` without support for callback
|
||
* shorthands and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to iterate over.
|
||
* @param {Function} iteratee The function invoked per iteration.
|
||
* @returns {Object} Returns `object`.
|
||
*/
|
||
function baseForOwn(object, iteratee) {
|
||
return baseFor(object, iteratee, keys);
|
||
}
|
||
|
||
module.exports = baseForOwn;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../object/keys":127,"./baseFor":82}],84:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseGet.js", module);
|
||
(function(){
|
||
var toObject = require('./toObject');
|
||
|
||
/**
|
||
* The base implementation of `get` without support for string paths
|
||
* and default values.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to query.
|
||
* @param {Array} path The path of the property to get.
|
||
* @param {string} [pathKey] The key representation of path.
|
||
* @returns {*} Returns the resolved value.
|
||
*/
|
||
function baseGet(object, path, pathKey) {
|
||
if (object == null) {
|
||
return;
|
||
}
|
||
if (pathKey !== undefined && pathKey in toObject(object)) {
|
||
path = [pathKey];
|
||
}
|
||
var index = 0,
|
||
length = path.length;
|
||
|
||
while (object != null && index < length) {
|
||
object = object[path[index++]];
|
||
}
|
||
return (index && index == length) ? object : undefined;
|
||
}
|
||
|
||
module.exports = baseGet;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./toObject":117}],85:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseIsEqual.js", module);
|
||
(function(){
|
||
var baseIsEqualDeep = require('./baseIsEqualDeep'),
|
||
isObject = require('../lang/isObject'),
|
||
isObjectLike = require('./isObjectLike');
|
||
|
||
/**
|
||
* The base implementation of `_.isEqual` without support for `this` binding
|
||
* `customizer` functions.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to compare.
|
||
* @param {*} other The other value to compare.
|
||
* @param {Function} [customizer] The function to customize comparing values.
|
||
* @param {boolean} [isLoose] Specify performing partial comparisons.
|
||
* @param {Array} [stackA] Tracks traversed `value` objects.
|
||
* @param {Array} [stackB] Tracks traversed `other` objects.
|
||
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
|
||
*/
|
||
function baseIsEqual(value, other, customizer, isLoose, stackA, stackB) {
|
||
if (value === other) {
|
||
return true;
|
||
}
|
||
if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {
|
||
return value !== value && other !== other;
|
||
}
|
||
return baseIsEqualDeep(value, other, baseIsEqual, customizer, isLoose, stackA, stackB);
|
||
}
|
||
|
||
module.exports = baseIsEqual;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../lang/isObject":123,"./baseIsEqualDeep":86,"./isObjectLike":114}],86:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseIsEqualDeep.js", module);
|
||
(function(){
|
||
var equalArrays = require('./equalArrays'),
|
||
equalByTag = require('./equalByTag'),
|
||
equalObjects = require('./equalObjects'),
|
||
isArray = require('../lang/isArray'),
|
||
isTypedArray = require('../lang/isTypedArray');
|
||
|
||
/** `Object#toString` result references. */
|
||
var argsTag = '[object Arguments]',
|
||
arrayTag = '[object Array]',
|
||
objectTag = '[object Object]';
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/**
|
||
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
||
* of values.
|
||
*/
|
||
var objToString = objectProto.toString;
|
||
|
||
/**
|
||
* A specialized version of `baseIsEqual` for arrays and objects which performs
|
||
* deep comparisons and tracks traversed objects enabling objects with circular
|
||
* references to be compared.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to compare.
|
||
* @param {Object} other The other object to compare.
|
||
* @param {Function} equalFunc The function to determine equivalents of values.
|
||
* @param {Function} [customizer] The function to customize comparing objects.
|
||
* @param {boolean} [isLoose] Specify performing partial comparisons.
|
||
* @param {Array} [stackA=[]] Tracks traversed `value` objects.
|
||
* @param {Array} [stackB=[]] Tracks traversed `other` objects.
|
||
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
|
||
*/
|
||
function baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA, stackB) {
|
||
var objIsArr = isArray(object),
|
||
othIsArr = isArray(other),
|
||
objTag = arrayTag,
|
||
othTag = arrayTag;
|
||
|
||
if (!objIsArr) {
|
||
objTag = objToString.call(object);
|
||
if (objTag == argsTag) {
|
||
objTag = objectTag;
|
||
} else if (objTag != objectTag) {
|
||
objIsArr = isTypedArray(object);
|
||
}
|
||
}
|
||
if (!othIsArr) {
|
||
othTag = objToString.call(other);
|
||
if (othTag == argsTag) {
|
||
othTag = objectTag;
|
||
} else if (othTag != objectTag) {
|
||
othIsArr = isTypedArray(other);
|
||
}
|
||
}
|
||
var objIsObj = objTag == objectTag,
|
||
othIsObj = othTag == objectTag,
|
||
isSameTag = objTag == othTag;
|
||
|
||
if (isSameTag && !(objIsArr || objIsObj)) {
|
||
return equalByTag(object, other, objTag);
|
||
}
|
||
if (!isLoose) {
|
||
var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
|
||
othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
|
||
|
||
if (objIsWrapped || othIsWrapped) {
|
||
return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, isLoose, stackA, stackB);
|
||
}
|
||
}
|
||
if (!isSameTag) {
|
||
return false;
|
||
}
|
||
// Assume cyclic values are equal.
|
||
// For more information on detecting circular references see https://es5.github.io/#JO.
|
||
stackA || (stackA = []);
|
||
stackB || (stackB = []);
|
||
|
||
var length = stackA.length;
|
||
while (length--) {
|
||
if (stackA[length] == object) {
|
||
return stackB[length] == other;
|
||
}
|
||
}
|
||
// Add `object` and `other` to the stack of traversed objects.
|
||
stackA.push(object);
|
||
stackB.push(other);
|
||
|
||
var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, isLoose, stackA, stackB);
|
||
|
||
stackA.pop();
|
||
stackB.pop();
|
||
|
||
return result;
|
||
}
|
||
|
||
module.exports = baseIsEqualDeep;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../lang/isArray":120,"../lang/isTypedArray":124,"./equalArrays":103,"./equalByTag":104,"./equalObjects":105}],87:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseIsMatch.js", module);
|
||
(function(){
|
||
var baseIsEqual = require('./baseIsEqual'),
|
||
toObject = require('./toObject');
|
||
|
||
/**
|
||
* The base implementation of `_.isMatch` without support for callback
|
||
* shorthands and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to inspect.
|
||
* @param {Array} matchData The propery names, values, and compare flags to match.
|
||
* @param {Function} [customizer] The function to customize comparing objects.
|
||
* @returns {boolean} Returns `true` if `object` is a match, else `false`.
|
||
*/
|
||
function baseIsMatch(object, matchData, customizer) {
|
||
var index = matchData.length,
|
||
length = index,
|
||
noCustomizer = !customizer;
|
||
|
||
if (object == null) {
|
||
return !length;
|
||
}
|
||
object = toObject(object);
|
||
while (index--) {
|
||
var data = matchData[index];
|
||
if ((noCustomizer && data[2])
|
||
? data[1] !== object[data[0]]
|
||
: !(data[0] in object)
|
||
) {
|
||
return false;
|
||
}
|
||
}
|
||
while (++index < length) {
|
||
data = matchData[index];
|
||
var key = data[0],
|
||
objValue = object[key],
|
||
srcValue = data[1];
|
||
|
||
if (noCustomizer && data[2]) {
|
||
if (objValue === undefined && !(key in object)) {
|
||
return false;
|
||
}
|
||
} else {
|
||
var result = customizer ? customizer(objValue, srcValue, key) : undefined;
|
||
if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, true) : result)) {
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
module.exports = baseIsMatch;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./baseIsEqual":85,"./toObject":117}],88:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseMap.js", module);
|
||
(function(){
|
||
var baseEach = require('./baseEach'),
|
||
isArrayLike = require('./isArrayLike');
|
||
|
||
/**
|
||
* The base implementation of `_.map` without support for callback shorthands
|
||
* and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Array|Object|string} collection The collection to iterate over.
|
||
* @param {Function} iteratee The function invoked per iteration.
|
||
* @returns {Array} Returns the new mapped array.
|
||
*/
|
||
function baseMap(collection, iteratee) {
|
||
var index = -1,
|
||
result = isArrayLike(collection) ? Array(collection.length) : [];
|
||
|
||
baseEach(collection, function(value, key, collection) {
|
||
result[++index] = iteratee(value, key, collection);
|
||
});
|
||
return result;
|
||
}
|
||
|
||
module.exports = baseMap;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./baseEach":80,"./isArrayLike":109}],89:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseMatches.js", module);
|
||
(function(){
|
||
var baseIsMatch = require('./baseIsMatch'),
|
||
getMatchData = require('./getMatchData'),
|
||
toObject = require('./toObject');
|
||
|
||
/**
|
||
* The base implementation of `_.matches` which does not clone `source`.
|
||
*
|
||
* @private
|
||
* @param {Object} source The object of property values to match.
|
||
* @returns {Function} Returns the new function.
|
||
*/
|
||
function baseMatches(source) {
|
||
var matchData = getMatchData(source);
|
||
if (matchData.length == 1 && matchData[0][2]) {
|
||
var key = matchData[0][0],
|
||
value = matchData[0][1];
|
||
|
||
return function(object) {
|
||
if (object == null) {
|
||
return false;
|
||
}
|
||
return object[key] === value && (value !== undefined || (key in toObject(object)));
|
||
};
|
||
}
|
||
return function(object) {
|
||
return baseIsMatch(object, matchData);
|
||
};
|
||
}
|
||
|
||
module.exports = baseMatches;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./baseIsMatch":87,"./getMatchData":107,"./toObject":117}],90:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseMatchesProperty.js", module);
|
||
(function(){
|
||
var baseGet = require('./baseGet'),
|
||
baseIsEqual = require('./baseIsEqual'),
|
||
baseSlice = require('./baseSlice'),
|
||
isArray = require('../lang/isArray'),
|
||
isKey = require('./isKey'),
|
||
isStrictComparable = require('./isStrictComparable'),
|
||
last = require('../array/last'),
|
||
toObject = require('./toObject'),
|
||
toPath = require('./toPath');
|
||
|
||
/**
|
||
* The base implementation of `_.matchesProperty` which does not clone `srcValue`.
|
||
*
|
||
* @private
|
||
* @param {string} path The path of the property to get.
|
||
* @param {*} srcValue The value to compare.
|
||
* @returns {Function} Returns the new function.
|
||
*/
|
||
function baseMatchesProperty(path, srcValue) {
|
||
var isArr = isArray(path),
|
||
isCommon = isKey(path) && isStrictComparable(srcValue),
|
||
pathKey = (path + '');
|
||
|
||
path = toPath(path);
|
||
return function(object) {
|
||
if (object == null) {
|
||
return false;
|
||
}
|
||
var key = pathKey;
|
||
object = toObject(object);
|
||
if ((isArr || !isCommon) && !(key in object)) {
|
||
object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));
|
||
if (object == null) {
|
||
return false;
|
||
}
|
||
key = last(path);
|
||
object = toObject(object);
|
||
}
|
||
return object[key] === srcValue
|
||
? (srcValue !== undefined || (key in object))
|
||
: baseIsEqual(srcValue, object[key], undefined, true);
|
||
};
|
||
}
|
||
|
||
module.exports = baseMatchesProperty;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../array/last":65,"../lang/isArray":120,"./baseGet":84,"./baseIsEqual":85,"./baseSlice":93,"./isKey":112,"./isStrictComparable":115,"./toObject":117,"./toPath":118}],91:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseProperty.js", module);
|
||
(function(){
|
||
/**
|
||
* The base implementation of `_.property` without support for deep paths.
|
||
*
|
||
* @private
|
||
* @param {string} key The key of the property to get.
|
||
* @returns {Function} Returns the new function.
|
||
*/
|
||
function baseProperty(key) {
|
||
return function(object) {
|
||
return object == null ? undefined : object[key];
|
||
};
|
||
}
|
||
|
||
module.exports = baseProperty;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],92:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/basePropertyDeep.js", module);
|
||
(function(){
|
||
var baseGet = require('./baseGet'),
|
||
toPath = require('./toPath');
|
||
|
||
/**
|
||
* A specialized version of `baseProperty` which supports deep paths.
|
||
*
|
||
* @private
|
||
* @param {Array|string} path The path of the property to get.
|
||
* @returns {Function} Returns the new function.
|
||
*/
|
||
function basePropertyDeep(path) {
|
||
var pathKey = (path + '');
|
||
path = toPath(path);
|
||
return function(object) {
|
||
return baseGet(object, path, pathKey);
|
||
};
|
||
}
|
||
|
||
module.exports = basePropertyDeep;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./baseGet":84,"./toPath":118}],93:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseSlice.js", module);
|
||
(function(){
|
||
/**
|
||
* The base implementation of `_.slice` without an iteratee call guard.
|
||
*
|
||
* @private
|
||
* @param {Array} array The array to slice.
|
||
* @param {number} [start=0] The start position.
|
||
* @param {number} [end=array.length] The end position.
|
||
* @returns {Array} Returns the slice of `array`.
|
||
*/
|
||
function baseSlice(array, start, end) {
|
||
var index = -1,
|
||
length = array.length;
|
||
|
||
start = start == null ? 0 : (+start || 0);
|
||
if (start < 0) {
|
||
start = -start > length ? 0 : (length + start);
|
||
}
|
||
end = (end === undefined || end > length) ? length : (+end || 0);
|
||
if (end < 0) {
|
||
end += length;
|
||
}
|
||
length = start > end ? 0 : ((end - start) >>> 0);
|
||
start >>>= 0;
|
||
|
||
var result = Array(length);
|
||
while (++index < length) {
|
||
result[index] = array[index + start];
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = baseSlice;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],94:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseSome.js", module);
|
||
(function(){
|
||
var baseEach = require('./baseEach');
|
||
|
||
/**
|
||
* The base implementation of `_.some` without support for callback shorthands
|
||
* and `this` binding.
|
||
*
|
||
* @private
|
||
* @param {Array|Object|string} collection The collection to iterate over.
|
||
* @param {Function} predicate The function invoked per iteration.
|
||
* @returns {boolean} Returns `true` if any element passes the predicate check,
|
||
* else `false`.
|
||
*/
|
||
function baseSome(collection, predicate) {
|
||
var result;
|
||
|
||
baseEach(collection, function(value, index, collection) {
|
||
result = predicate(value, index, collection);
|
||
return !result;
|
||
});
|
||
return !!result;
|
||
}
|
||
|
||
module.exports = baseSome;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./baseEach":80}],95:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/baseToString.js", module);
|
||
(function(){
|
||
/**
|
||
* Converts `value` to a string if it's not one. An empty string is returned
|
||
* for `null` or `undefined` values.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to process.
|
||
* @returns {string} Returns the string.
|
||
*/
|
||
function baseToString(value) {
|
||
return value == null ? '' : (value + '');
|
||
}
|
||
|
||
module.exports = baseToString;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],96:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/bindCallback.js", module);
|
||
(function(){
|
||
var identity = require('../utility/identity');
|
||
|
||
/**
|
||
* A specialized version of `baseCallback` which only supports `this` binding
|
||
* and specifying the number of arguments to provide to `func`.
|
||
*
|
||
* @private
|
||
* @param {Function} func The function to bind.
|
||
* @param {*} thisArg The `this` binding of `func`.
|
||
* @param {number} [argCount] The number of arguments to provide to `func`.
|
||
* @returns {Function} Returns the callback.
|
||
*/
|
||
function bindCallback(func, thisArg, argCount) {
|
||
if (typeof func != 'function') {
|
||
return identity;
|
||
}
|
||
if (thisArg === undefined) {
|
||
return func;
|
||
}
|
||
switch (argCount) {
|
||
case 1: return function(value) {
|
||
return func.call(thisArg, value);
|
||
};
|
||
case 3: return function(value, index, collection) {
|
||
return func.call(thisArg, value, index, collection);
|
||
};
|
||
case 4: return function(accumulator, value, index, collection) {
|
||
return func.call(thisArg, accumulator, value, index, collection);
|
||
};
|
||
case 5: return function(value, other, key, object, source) {
|
||
return func.call(thisArg, value, other, key, object, source);
|
||
};
|
||
}
|
||
return function() {
|
||
return func.apply(thisArg, arguments);
|
||
};
|
||
}
|
||
|
||
module.exports = bindCallback;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../utility/identity":131}],97:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/createAssigner.js", module);
|
||
(function(){
|
||
var bindCallback = require('./bindCallback'),
|
||
isIterateeCall = require('./isIterateeCall'),
|
||
restParam = require('../function/restParam');
|
||
|
||
/**
|
||
* Creates a `_.assign`, `_.defaults`, or `_.merge` function.
|
||
*
|
||
* @private
|
||
* @param {Function} assigner The function to assign values.
|
||
* @returns {Function} Returns the new assigner function.
|
||
*/
|
||
function createAssigner(assigner) {
|
||
return restParam(function(object, sources) {
|
||
var index = -1,
|
||
length = object == null ? 0 : sources.length,
|
||
customizer = length > 2 ? sources[length - 2] : undefined,
|
||
guard = length > 2 ? sources[2] : undefined,
|
||
thisArg = length > 1 ? sources[length - 1] : undefined;
|
||
|
||
if (typeof customizer == 'function') {
|
||
customizer = bindCallback(customizer, thisArg, 5);
|
||
length -= 2;
|
||
} else {
|
||
customizer = typeof thisArg == 'function' ? thisArg : undefined;
|
||
length -= (customizer ? 1 : 0);
|
||
}
|
||
if (guard && isIterateeCall(sources[0], sources[1], guard)) {
|
||
customizer = length < 3 ? undefined : customizer;
|
||
length = 1;
|
||
}
|
||
while (++index < length) {
|
||
var source = sources[index];
|
||
if (source) {
|
||
assigner(object, source, customizer);
|
||
}
|
||
}
|
||
return object;
|
||
});
|
||
}
|
||
|
||
module.exports = createAssigner;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../function/restParam":71,"./bindCallback":96,"./isIterateeCall":111}],98:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/createBaseEach.js", module);
|
||
(function(){
|
||
var getLength = require('./getLength'),
|
||
isLength = require('./isLength'),
|
||
toObject = require('./toObject');
|
||
|
||
/**
|
||
* Creates a `baseEach` or `baseEachRight` function.
|
||
*
|
||
* @private
|
||
* @param {Function} eachFunc The function to iterate over a collection.
|
||
* @param {boolean} [fromRight] Specify iterating from right to left.
|
||
* @returns {Function} Returns the new base function.
|
||
*/
|
||
function createBaseEach(eachFunc, fromRight) {
|
||
return function(collection, iteratee) {
|
||
var length = collection ? getLength(collection) : 0;
|
||
if (!isLength(length)) {
|
||
return eachFunc(collection, iteratee);
|
||
}
|
||
var index = fromRight ? length : -1,
|
||
iterable = toObject(collection);
|
||
|
||
while ((fromRight ? index-- : ++index < length)) {
|
||
if (iteratee(iterable[index], index, iterable) === false) {
|
||
break;
|
||
}
|
||
}
|
||
return collection;
|
||
};
|
||
}
|
||
|
||
module.exports = createBaseEach;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./getLength":106,"./isLength":113,"./toObject":117}],99:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/createBaseFor.js", module);
|
||
(function(){
|
||
var toObject = require('./toObject');
|
||
|
||
/**
|
||
* Creates a base function for `_.forIn` or `_.forInRight`.
|
||
*
|
||
* @private
|
||
* @param {boolean} [fromRight] Specify iterating from right to left.
|
||
* @returns {Function} Returns the new base function.
|
||
*/
|
||
function createBaseFor(fromRight) {
|
||
return function(object, iteratee, keysFunc) {
|
||
var iterable = toObject(object),
|
||
props = keysFunc(object),
|
||
length = props.length,
|
||
index = fromRight ? length : -1;
|
||
|
||
while ((fromRight ? index-- : ++index < length)) {
|
||
var key = props[index];
|
||
if (iteratee(iterable[key], key, iterable) === false) {
|
||
break;
|
||
}
|
||
}
|
||
return object;
|
||
};
|
||
}
|
||
|
||
module.exports = createBaseFor;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./toObject":117}],100:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/createForEach.js", module);
|
||
(function(){
|
||
var bindCallback = require('./bindCallback'),
|
||
isArray = require('../lang/isArray');
|
||
|
||
/**
|
||
* Creates a function for `_.forEach` or `_.forEachRight`.
|
||
*
|
||
* @private
|
||
* @param {Function} arrayFunc The function to iterate over an array.
|
||
* @param {Function} eachFunc The function to iterate over a collection.
|
||
* @returns {Function} Returns the new each function.
|
||
*/
|
||
function createForEach(arrayFunc, eachFunc) {
|
||
return function(collection, iteratee, thisArg) {
|
||
return (typeof iteratee == 'function' && thisArg === undefined && isArray(collection))
|
||
? arrayFunc(collection, iteratee)
|
||
: eachFunc(collection, bindCallback(iteratee, thisArg, 3));
|
||
};
|
||
}
|
||
|
||
module.exports = createForEach;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../lang/isArray":120,"./bindCallback":96}],101:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/createForOwn.js", module);
|
||
(function(){
|
||
var bindCallback = require('./bindCallback');
|
||
|
||
/**
|
||
* Creates a function for `_.forOwn` or `_.forOwnRight`.
|
||
*
|
||
* @private
|
||
* @param {Function} objectFunc The function to iterate over an object.
|
||
* @returns {Function} Returns the new each function.
|
||
*/
|
||
function createForOwn(objectFunc) {
|
||
return function(object, iteratee, thisArg) {
|
||
if (typeof iteratee != 'function' || thisArg !== undefined) {
|
||
iteratee = bindCallback(iteratee, thisArg, 3);
|
||
}
|
||
return objectFunc(object, iteratee);
|
||
};
|
||
}
|
||
|
||
module.exports = createForOwn;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./bindCallback":96}],102:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/createObjectMapper.js", module);
|
||
(function(){
|
||
var baseCallback = require('./baseCallback'),
|
||
baseForOwn = require('./baseForOwn');
|
||
|
||
/**
|
||
* Creates a function for `_.mapKeys` or `_.mapValues`.
|
||
*
|
||
* @private
|
||
* @param {boolean} [isMapKeys] Specify mapping keys instead of values.
|
||
* @returns {Function} Returns the new map function.
|
||
*/
|
||
function createObjectMapper(isMapKeys) {
|
||
return function(object, iteratee, thisArg) {
|
||
var result = {};
|
||
iteratee = baseCallback(iteratee, thisArg, 3);
|
||
|
||
baseForOwn(object, function(value, key, object) {
|
||
var mapped = iteratee(value, key, object);
|
||
key = isMapKeys ? mapped : key;
|
||
value = isMapKeys ? value : mapped;
|
||
result[key] = value;
|
||
});
|
||
return result;
|
||
};
|
||
}
|
||
|
||
module.exports = createObjectMapper;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./baseCallback":78,"./baseForOwn":83}],103:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/equalArrays.js", module);
|
||
(function(){
|
||
var arraySome = require('./arraySome');
|
||
|
||
/**
|
||
* A specialized version of `baseIsEqualDeep` for arrays with support for
|
||
* partial deep comparisons.
|
||
*
|
||
* @private
|
||
* @param {Array} array The array to compare.
|
||
* @param {Array} other The other array to compare.
|
||
* @param {Function} equalFunc The function to determine equivalents of values.
|
||
* @param {Function} [customizer] The function to customize comparing arrays.
|
||
* @param {boolean} [isLoose] Specify performing partial comparisons.
|
||
* @param {Array} [stackA] Tracks traversed `value` objects.
|
||
* @param {Array} [stackB] Tracks traversed `other` objects.
|
||
* @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
|
||
*/
|
||
function equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) {
|
||
var index = -1,
|
||
arrLength = array.length,
|
||
othLength = other.length;
|
||
|
||
if (arrLength != othLength && !(isLoose && othLength > arrLength)) {
|
||
return false;
|
||
}
|
||
// Ignore non-index properties.
|
||
while (++index < arrLength) {
|
||
var arrValue = array[index],
|
||
othValue = other[index],
|
||
result = customizer ? customizer(isLoose ? othValue : arrValue, isLoose ? arrValue : othValue, index) : undefined;
|
||
|
||
if (result !== undefined) {
|
||
if (result) {
|
||
continue;
|
||
}
|
||
return false;
|
||
}
|
||
// Recursively compare arrays (susceptible to call stack limits).
|
||
if (isLoose) {
|
||
if (!arraySome(other, function(othValue) {
|
||
return arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB);
|
||
})) {
|
||
return false;
|
||
}
|
||
} else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB))) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
module.exports = equalArrays;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./arraySome":75}],104:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/equalByTag.js", module);
|
||
(function(){
|
||
/** `Object#toString` result references. */
|
||
var boolTag = '[object Boolean]',
|
||
dateTag = '[object Date]',
|
||
errorTag = '[object Error]',
|
||
numberTag = '[object Number]',
|
||
regexpTag = '[object RegExp]',
|
||
stringTag = '[object String]';
|
||
|
||
/**
|
||
* A specialized version of `baseIsEqualDeep` for comparing objects of
|
||
* the same `toStringTag`.
|
||
*
|
||
* **Note:** This function only supports comparing values with tags of
|
||
* `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to compare.
|
||
* @param {Object} other The other object to compare.
|
||
* @param {string} tag The `toStringTag` of the objects to compare.
|
||
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
|
||
*/
|
||
function equalByTag(object, other, tag) {
|
||
switch (tag) {
|
||
case boolTag:
|
||
case dateTag:
|
||
// Coerce dates and booleans to numbers, dates to milliseconds and booleans
|
||
// to `1` or `0` treating invalid dates coerced to `NaN` as not equal.
|
||
return +object == +other;
|
||
|
||
case errorTag:
|
||
return object.name == other.name && object.message == other.message;
|
||
|
||
case numberTag:
|
||
// Treat `NaN` vs. `NaN` as equal.
|
||
return (object != +object)
|
||
? other != +other
|
||
: object == +other;
|
||
|
||
case regexpTag:
|
||
case stringTag:
|
||
// Coerce regexes to strings and treat strings primitives and string
|
||
// objects as equal. See https://es5.github.io/#x15.10.6.4 for more details.
|
||
return object == (other + '');
|
||
}
|
||
return false;
|
||
}
|
||
|
||
module.exports = equalByTag;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],105:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/equalObjects.js", module);
|
||
(function(){
|
||
var keys = require('../object/keys');
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/**
|
||
* A specialized version of `baseIsEqualDeep` for objects with support for
|
||
* partial deep comparisons.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to compare.
|
||
* @param {Object} other The other object to compare.
|
||
* @param {Function} equalFunc The function to determine equivalents of values.
|
||
* @param {Function} [customizer] The function to customize comparing values.
|
||
* @param {boolean} [isLoose] Specify performing partial comparisons.
|
||
* @param {Array} [stackA] Tracks traversed `value` objects.
|
||
* @param {Array} [stackB] Tracks traversed `other` objects.
|
||
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
|
||
*/
|
||
function equalObjects(object, other, equalFunc, customizer, isLoose, stackA, stackB) {
|
||
var objProps = keys(object),
|
||
objLength = objProps.length,
|
||
othProps = keys(other),
|
||
othLength = othProps.length;
|
||
|
||
if (objLength != othLength && !isLoose) {
|
||
return false;
|
||
}
|
||
var index = objLength;
|
||
while (index--) {
|
||
var key = objProps[index];
|
||
if (!(isLoose ? key in other : hasOwnProperty.call(other, key))) {
|
||
return false;
|
||
}
|
||
}
|
||
var skipCtor = isLoose;
|
||
while (++index < objLength) {
|
||
key = objProps[index];
|
||
var objValue = object[key],
|
||
othValue = other[key],
|
||
result = customizer ? customizer(isLoose ? othValue : objValue, isLoose? objValue : othValue, key) : undefined;
|
||
|
||
// Recursively compare objects (susceptible to call stack limits).
|
||
if (!(result === undefined ? equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB) : result)) {
|
||
return false;
|
||
}
|
||
skipCtor || (skipCtor = key == 'constructor');
|
||
}
|
||
if (!skipCtor) {
|
||
var objCtor = object.constructor,
|
||
othCtor = other.constructor;
|
||
|
||
// Non `Object` object instances with different constructors are not equal.
|
||
if (objCtor != othCtor &&
|
||
('constructor' in object && 'constructor' in other) &&
|
||
!(typeof objCtor == 'function' && objCtor instanceof objCtor &&
|
||
typeof othCtor == 'function' && othCtor instanceof othCtor)) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
module.exports = equalObjects;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../object/keys":127}],106:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/getLength.js", module);
|
||
(function(){
|
||
var baseProperty = require('./baseProperty');
|
||
|
||
/**
|
||
* Gets the "length" property value of `object`.
|
||
*
|
||
* **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)
|
||
* that affects Safari on at least iOS 8.1-8.3 ARM64.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to query.
|
||
* @returns {*} Returns the "length" value.
|
||
*/
|
||
var getLength = baseProperty('length');
|
||
|
||
module.exports = getLength;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./baseProperty":91}],107:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/getMatchData.js", module);
|
||
(function(){
|
||
var isStrictComparable = require('./isStrictComparable'),
|
||
pairs = require('../object/pairs');
|
||
|
||
/**
|
||
* Gets the propery names, values, and compare flags of `object`.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to query.
|
||
* @returns {Array} Returns the match data of `object`.
|
||
*/
|
||
function getMatchData(object) {
|
||
var result = pairs(object),
|
||
length = result.length;
|
||
|
||
while (length--) {
|
||
result[length][2] = isStrictComparable(result[length][1]);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = getMatchData;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../object/pairs":130,"./isStrictComparable":115}],108:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/getNative.js", module);
|
||
(function(){
|
||
var isNative = require('../lang/isNative');
|
||
|
||
/**
|
||
* Gets the native function at `key` of `object`.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to query.
|
||
* @param {string} key The key of the method to get.
|
||
* @returns {*} Returns the function if it's native, else `undefined`.
|
||
*/
|
||
function getNative(object, key) {
|
||
var value = object == null ? undefined : object[key];
|
||
return isNative(value) ? value : undefined;
|
||
}
|
||
|
||
module.exports = getNative;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../lang/isNative":122}],109:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/isArrayLike.js", module);
|
||
(function(){
|
||
var getLength = require('./getLength'),
|
||
isLength = require('./isLength');
|
||
|
||
/**
|
||
* Checks if `value` is array-like.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is array-like, else `false`.
|
||
*/
|
||
function isArrayLike(value) {
|
||
return value != null && isLength(getLength(value));
|
||
}
|
||
|
||
module.exports = isArrayLike;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./getLength":106,"./isLength":113}],110:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/isIndex.js", module);
|
||
(function(){
|
||
/** Used to detect unsigned integer values. */
|
||
var reIsUint = /^\d+$/;
|
||
|
||
/**
|
||
* Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
|
||
* of an array-like value.
|
||
*/
|
||
var MAX_SAFE_INTEGER = 9007199254740991;
|
||
|
||
/**
|
||
* Checks if `value` is a valid array-like index.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
|
||
* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
|
||
*/
|
||
function isIndex(value, length) {
|
||
value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;
|
||
length = length == null ? MAX_SAFE_INTEGER : length;
|
||
return value > -1 && value % 1 == 0 && value < length;
|
||
}
|
||
|
||
module.exports = isIndex;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],111:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/isIterateeCall.js", module);
|
||
(function(){
|
||
var isArrayLike = require('./isArrayLike'),
|
||
isIndex = require('./isIndex'),
|
||
isObject = require('../lang/isObject');
|
||
|
||
/**
|
||
* Checks if the provided arguments are from an iteratee call.
|
||
*
|
||
* @private
|
||
* @param {*} value The potential iteratee value argument.
|
||
* @param {*} index The potential iteratee index or key argument.
|
||
* @param {*} object The potential iteratee object argument.
|
||
* @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`.
|
||
*/
|
||
function isIterateeCall(value, index, object) {
|
||
if (!isObject(object)) {
|
||
return false;
|
||
}
|
||
var type = typeof index;
|
||
if (type == 'number'
|
||
? (isArrayLike(object) && isIndex(index, object.length))
|
||
: (type == 'string' && index in object)) {
|
||
var other = object[index];
|
||
return value === value ? (value === other) : (other !== other);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
module.exports = isIterateeCall;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../lang/isObject":123,"./isArrayLike":109,"./isIndex":110}],112:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/isKey.js", module);
|
||
(function(){
|
||
var isArray = require('../lang/isArray'),
|
||
toObject = require('./toObject');
|
||
|
||
/** Used to match property names within property paths. */
|
||
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\n\\]|\\.)*?\1)\]/,
|
||
reIsPlainProp = /^\w*$/;
|
||
|
||
/**
|
||
* Checks if `value` is a property name and not a property path.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @param {Object} [object] The object to query keys on.
|
||
* @returns {boolean} Returns `true` if `value` is a property name, else `false`.
|
||
*/
|
||
function isKey(value, object) {
|
||
var type = typeof value;
|
||
if ((type == 'string' && reIsPlainProp.test(value)) || type == 'number') {
|
||
return true;
|
||
}
|
||
if (isArray(value)) {
|
||
return false;
|
||
}
|
||
var result = !reIsDeepProp.test(value);
|
||
return result || (object != null && value in toObject(object));
|
||
}
|
||
|
||
module.exports = isKey;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../lang/isArray":120,"./toObject":117}],113:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/isLength.js", module);
|
||
(function(){
|
||
/**
|
||
* Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
|
||
* of an array-like value.
|
||
*/
|
||
var MAX_SAFE_INTEGER = 9007199254740991;
|
||
|
||
/**
|
||
* Checks if `value` is a valid array-like length.
|
||
*
|
||
* **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
|
||
*/
|
||
function isLength(value) {
|
||
return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
|
||
}
|
||
|
||
module.exports = isLength;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],114:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/isObjectLike.js", module);
|
||
(function(){
|
||
/**
|
||
* Checks if `value` is object-like.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
|
||
*/
|
||
function isObjectLike(value) {
|
||
return !!value && typeof value == 'object';
|
||
}
|
||
|
||
module.exports = isObjectLike;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],115:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/isStrictComparable.js", module);
|
||
(function(){
|
||
var isObject = require('../lang/isObject');
|
||
|
||
/**
|
||
* Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` if suitable for strict
|
||
* equality comparisons, else `false`.
|
||
*/
|
||
function isStrictComparable(value) {
|
||
return value === value && !isObject(value);
|
||
}
|
||
|
||
module.exports = isStrictComparable;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../lang/isObject":123}],116:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/shimKeys.js", module);
|
||
(function(){
|
||
var isArguments = require('../lang/isArguments'),
|
||
isArray = require('../lang/isArray'),
|
||
isIndex = require('./isIndex'),
|
||
isLength = require('./isLength'),
|
||
keysIn = require('../object/keysIn');
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/**
|
||
* A fallback implementation of `Object.keys` which creates an array of the
|
||
* own enumerable property names of `object`.
|
||
*
|
||
* @private
|
||
* @param {Object} object The object to query.
|
||
* @returns {Array} Returns the array of property names.
|
||
*/
|
||
function shimKeys(object) {
|
||
var props = keysIn(object),
|
||
propsLength = props.length,
|
||
length = propsLength && object.length;
|
||
|
||
var allowIndexes = !!length && isLength(length) &&
|
||
(isArray(object) || isArguments(object));
|
||
|
||
var index = -1,
|
||
result = [];
|
||
|
||
while (++index < propsLength) {
|
||
var key = props[index];
|
||
if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) {
|
||
result.push(key);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = shimKeys;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../lang/isArguments":119,"../lang/isArray":120,"../object/keysIn":128,"./isIndex":110,"./isLength":113}],117:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/toObject.js", module);
|
||
(function(){
|
||
var isObject = require('../lang/isObject');
|
||
|
||
/**
|
||
* Converts `value` to an object if it's not one.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to process.
|
||
* @returns {Object} Returns the object.
|
||
*/
|
||
function toObject(value) {
|
||
return isObject(value) ? value : Object(value);
|
||
}
|
||
|
||
module.exports = toObject;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../lang/isObject":123}],118:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/internal/toPath.js", module);
|
||
(function(){
|
||
var baseToString = require('./baseToString'),
|
||
isArray = require('../lang/isArray');
|
||
|
||
/** Used to match property names within property paths. */
|
||
var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\n\\]|\\.)*?)\2)\]/g;
|
||
|
||
/** Used to match backslashes in property paths. */
|
||
var reEscapeChar = /\\(\\)?/g;
|
||
|
||
/**
|
||
* Converts `value` to property path array if it's not one.
|
||
*
|
||
* @private
|
||
* @param {*} value The value to process.
|
||
* @returns {Array} Returns the property path array.
|
||
*/
|
||
function toPath(value) {
|
||
if (isArray(value)) {
|
||
return value;
|
||
}
|
||
var result = [];
|
||
baseToString(value).replace(rePropName, function(match, number, quote, string) {
|
||
result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
|
||
});
|
||
return result;
|
||
}
|
||
|
||
module.exports = toPath;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../lang/isArray":120,"./baseToString":95}],119:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/lang/isArguments.js", module);
|
||
(function(){
|
||
var isArrayLike = require('../internal/isArrayLike'),
|
||
isObjectLike = require('../internal/isObjectLike');
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/** Native method references. */
|
||
var propertyIsEnumerable = objectProto.propertyIsEnumerable;
|
||
|
||
/**
|
||
* Checks if `value` is classified as an `arguments` object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
||
* @example
|
||
*
|
||
* _.isArguments(function() { return arguments; }());
|
||
* // => true
|
||
*
|
||
* _.isArguments([1, 2, 3]);
|
||
* // => false
|
||
*/
|
||
function isArguments(value) {
|
||
return isObjectLike(value) && isArrayLike(value) &&
|
||
hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
|
||
}
|
||
|
||
module.exports = isArguments;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/isArrayLike":109,"../internal/isObjectLike":114}],120:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/lang/isArray.js", module);
|
||
(function(){
|
||
var getNative = require('../internal/getNative'),
|
||
isLength = require('../internal/isLength'),
|
||
isObjectLike = require('../internal/isObjectLike');
|
||
|
||
/** `Object#toString` result references. */
|
||
var arrayTag = '[object Array]';
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/**
|
||
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
||
* of values.
|
||
*/
|
||
var objToString = objectProto.toString;
|
||
|
||
/* Native method references for those with the same name as other `lodash` methods. */
|
||
var nativeIsArray = getNative(Array, 'isArray');
|
||
|
||
/**
|
||
* Checks if `value` is classified as an `Array` object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
||
* @example
|
||
*
|
||
* _.isArray([1, 2, 3]);
|
||
* // => true
|
||
*
|
||
* _.isArray(function() { return arguments; }());
|
||
* // => false
|
||
*/
|
||
var isArray = nativeIsArray || function(value) {
|
||
return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;
|
||
};
|
||
|
||
module.exports = isArray;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/getNative":108,"../internal/isLength":113,"../internal/isObjectLike":114}],121:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/lang/isFunction.js", module);
|
||
(function(){
|
||
var isObject = require('./isObject');
|
||
|
||
/** `Object#toString` result references. */
|
||
var funcTag = '[object Function]';
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/**
|
||
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
||
* of values.
|
||
*/
|
||
var objToString = objectProto.toString;
|
||
|
||
/**
|
||
* Checks if `value` is classified as a `Function` object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
||
* @example
|
||
*
|
||
* _.isFunction(_);
|
||
* // => true
|
||
*
|
||
* _.isFunction(/abc/);
|
||
* // => false
|
||
*/
|
||
function isFunction(value) {
|
||
// The use of `Object#toString` avoids issues with the `typeof` operator
|
||
// in older versions of Chrome and Safari which return 'function' for regexes
|
||
// and Safari 8 which returns 'object' for typed array constructors.
|
||
return isObject(value) && objToString.call(value) == funcTag;
|
||
}
|
||
|
||
module.exports = isFunction;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./isObject":123}],122:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/lang/isNative.js", module);
|
||
(function(){
|
||
var isFunction = require('./isFunction'),
|
||
isObjectLike = require('../internal/isObjectLike');
|
||
|
||
/** Used to detect host constructors (Safari > 5). */
|
||
var reIsHostCtor = /^\[object .+?Constructor\]$/;
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to resolve the decompiled source of functions. */
|
||
var fnToString = Function.prototype.toString;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/** Used to detect if a method is native. */
|
||
var reIsNative = RegExp('^' +
|
||
fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
|
||
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
|
||
);
|
||
|
||
/**
|
||
* Checks if `value` is a native function.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is a native function, else `false`.
|
||
* @example
|
||
*
|
||
* _.isNative(Array.prototype.push);
|
||
* // => true
|
||
*
|
||
* _.isNative(_);
|
||
* // => false
|
||
*/
|
||
function isNative(value) {
|
||
if (value == null) {
|
||
return false;
|
||
}
|
||
if (isFunction(value)) {
|
||
return reIsNative.test(fnToString.call(value));
|
||
}
|
||
return isObjectLike(value) && reIsHostCtor.test(value);
|
||
}
|
||
|
||
module.exports = isNative;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/isObjectLike":114,"./isFunction":121}],123:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/lang/isObject.js", module);
|
||
(function(){
|
||
/**
|
||
* Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
|
||
* (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
|
||
* @example
|
||
*
|
||
* _.isObject({});
|
||
* // => true
|
||
*
|
||
* _.isObject([1, 2, 3]);
|
||
* // => true
|
||
*
|
||
* _.isObject(1);
|
||
* // => false
|
||
*/
|
||
function isObject(value) {
|
||
// Avoid a V8 JIT bug in Chrome 19-20.
|
||
// See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
|
||
var type = typeof value;
|
||
return !!value && (type == 'object' || type == 'function');
|
||
}
|
||
|
||
module.exports = isObject;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],124:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/lang/isTypedArray.js", module);
|
||
(function(){
|
||
var isLength = require('../internal/isLength'),
|
||
isObjectLike = require('../internal/isObjectLike');
|
||
|
||
/** `Object#toString` result references. */
|
||
var argsTag = '[object Arguments]',
|
||
arrayTag = '[object Array]',
|
||
boolTag = '[object Boolean]',
|
||
dateTag = '[object Date]',
|
||
errorTag = '[object Error]',
|
||
funcTag = '[object Function]',
|
||
mapTag = '[object Map]',
|
||
numberTag = '[object Number]',
|
||
objectTag = '[object Object]',
|
||
regexpTag = '[object RegExp]',
|
||
setTag = '[object Set]',
|
||
stringTag = '[object String]',
|
||
weakMapTag = '[object WeakMap]';
|
||
|
||
var arrayBufferTag = '[object ArrayBuffer]',
|
||
float32Tag = '[object Float32Array]',
|
||
float64Tag = '[object Float64Array]',
|
||
int8Tag = '[object Int8Array]',
|
||
int16Tag = '[object Int16Array]',
|
||
int32Tag = '[object Int32Array]',
|
||
uint8Tag = '[object Uint8Array]',
|
||
uint8ClampedTag = '[object Uint8ClampedArray]',
|
||
uint16Tag = '[object Uint16Array]',
|
||
uint32Tag = '[object Uint32Array]';
|
||
|
||
/** Used to identify `toStringTag` values of typed arrays. */
|
||
var typedArrayTags = {};
|
||
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
|
||
typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
|
||
typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
|
||
typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
|
||
typedArrayTags[uint32Tag] = true;
|
||
typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
|
||
typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
|
||
typedArrayTags[dateTag] = typedArrayTags[errorTag] =
|
||
typedArrayTags[funcTag] = typedArrayTags[mapTag] =
|
||
typedArrayTags[numberTag] = typedArrayTags[objectTag] =
|
||
typedArrayTags[regexpTag] = typedArrayTags[setTag] =
|
||
typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/**
|
||
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
|
||
* of values.
|
||
*/
|
||
var objToString = objectProto.toString;
|
||
|
||
/**
|
||
* Checks if `value` is classified as a typed array.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Lang
|
||
* @param {*} value The value to check.
|
||
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
|
||
* @example
|
||
*
|
||
* _.isTypedArray(new Uint8Array);
|
||
* // => true
|
||
*
|
||
* _.isTypedArray([]);
|
||
* // => false
|
||
*/
|
||
function isTypedArray(value) {
|
||
return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)];
|
||
}
|
||
|
||
module.exports = isTypedArray;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/isLength":113,"../internal/isObjectLike":114}],125:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/object/assign.js", module);
|
||
(function(){
|
||
var assignWith = require('../internal/assignWith'),
|
||
baseAssign = require('../internal/baseAssign'),
|
||
createAssigner = require('../internal/createAssigner');
|
||
|
||
/**
|
||
* Assigns own enumerable properties of source object(s) to the destination
|
||
* object. Subsequent sources overwrite property assignments of previous sources.
|
||
* If `customizer` is provided it's invoked to produce the assigned values.
|
||
* The `customizer` is bound to `thisArg` and invoked with five arguments:
|
||
* (objectValue, sourceValue, key, object, source).
|
||
*
|
||
* **Note:** This method mutates `object` and is based on
|
||
* [`Object.assign`](http://ecma-international.org/ecma-262/6.0/#sec-object.assign).
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @alias extend
|
||
* @category Object
|
||
* @param {Object} object The destination object.
|
||
* @param {...Object} [sources] The source objects.
|
||
* @param {Function} [customizer] The function to customize assigned values.
|
||
* @param {*} [thisArg] The `this` binding of `customizer`.
|
||
* @returns {Object} Returns `object`.
|
||
* @example
|
||
*
|
||
* _.assign({ 'user': 'barney' }, { 'age': 40 }, { 'user': 'fred' });
|
||
* // => { 'user': 'fred', 'age': 40 }
|
||
*
|
||
* // using a customizer callback
|
||
* var defaults = _.partialRight(_.assign, function(value, other) {
|
||
* return _.isUndefined(value) ? other : value;
|
||
* });
|
||
*
|
||
* defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });
|
||
* // => { 'user': 'barney', 'age': 36 }
|
||
*/
|
||
var assign = createAssigner(function(object, source, customizer) {
|
||
return customizer
|
||
? assignWith(object, source, customizer)
|
||
: baseAssign(object, source);
|
||
});
|
||
|
||
module.exports = assign;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/assignWith":76,"../internal/baseAssign":77,"../internal/createAssigner":97}],126:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/object/forOwn.js", module);
|
||
(function(){
|
||
var baseForOwn = require('../internal/baseForOwn'),
|
||
createForOwn = require('../internal/createForOwn');
|
||
|
||
/**
|
||
* Iterates over own enumerable properties of an object invoking `iteratee`
|
||
* for each property. The `iteratee` is bound to `thisArg` and invoked with
|
||
* three arguments: (value, key, object). Iteratee functions may exit iteration
|
||
* early by explicitly returning `false`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Object
|
||
* @param {Object} object The object to iterate over.
|
||
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
|
||
* @param {*} [thisArg] The `this` binding of `iteratee`.
|
||
* @returns {Object} Returns `object`.
|
||
* @example
|
||
*
|
||
* function Foo() {
|
||
* this.a = 1;
|
||
* this.b = 2;
|
||
* }
|
||
*
|
||
* Foo.prototype.c = 3;
|
||
*
|
||
* _.forOwn(new Foo, function(value, key) {
|
||
* console.log(key);
|
||
* });
|
||
* // => logs 'a' and 'b' (iteration order is not guaranteed)
|
||
*/
|
||
var forOwn = createForOwn(baseForOwn);
|
||
|
||
module.exports = forOwn;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/baseForOwn":83,"../internal/createForOwn":101}],127:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/object/keys.js", module);
|
||
(function(){
|
||
var getNative = require('../internal/getNative'),
|
||
isArrayLike = require('../internal/isArrayLike'),
|
||
isObject = require('../lang/isObject'),
|
||
shimKeys = require('../internal/shimKeys');
|
||
|
||
/* Native method references for those with the same name as other `lodash` methods. */
|
||
var nativeKeys = getNative(Object, 'keys');
|
||
|
||
/**
|
||
* Creates an array of the own enumerable property names of `object`.
|
||
*
|
||
* **Note:** Non-object values are coerced to objects. See the
|
||
* [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys)
|
||
* for more details.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Object
|
||
* @param {Object} object The object to query.
|
||
* @returns {Array} Returns the array of property names.
|
||
* @example
|
||
*
|
||
* function Foo() {
|
||
* this.a = 1;
|
||
* this.b = 2;
|
||
* }
|
||
*
|
||
* Foo.prototype.c = 3;
|
||
*
|
||
* _.keys(new Foo);
|
||
* // => ['a', 'b'] (iteration order is not guaranteed)
|
||
*
|
||
* _.keys('hi');
|
||
* // => ['0', '1']
|
||
*/
|
||
var keys = !nativeKeys ? shimKeys : function(object) {
|
||
var Ctor = object == null ? undefined : object.constructor;
|
||
if ((typeof Ctor == 'function' && Ctor.prototype === object) ||
|
||
(typeof object != 'function' && isArrayLike(object))) {
|
||
return shimKeys(object);
|
||
}
|
||
return isObject(object) ? nativeKeys(object) : [];
|
||
};
|
||
|
||
module.exports = keys;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/getNative":108,"../internal/isArrayLike":109,"../internal/shimKeys":116,"../lang/isObject":123}],128:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/object/keysIn.js", module);
|
||
(function(){
|
||
var isArguments = require('../lang/isArguments'),
|
||
isArray = require('../lang/isArray'),
|
||
isIndex = require('../internal/isIndex'),
|
||
isLength = require('../internal/isLength'),
|
||
isObject = require('../lang/isObject');
|
||
|
||
/** Used for native method references. */
|
||
var objectProto = Object.prototype;
|
||
|
||
/** Used to check objects for own properties. */
|
||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||
|
||
/**
|
||
* Creates an array of the own and inherited enumerable property names of `object`.
|
||
*
|
||
* **Note:** Non-object values are coerced to objects.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Object
|
||
* @param {Object} object The object to query.
|
||
* @returns {Array} Returns the array of property names.
|
||
* @example
|
||
*
|
||
* function Foo() {
|
||
* this.a = 1;
|
||
* this.b = 2;
|
||
* }
|
||
*
|
||
* Foo.prototype.c = 3;
|
||
*
|
||
* _.keysIn(new Foo);
|
||
* // => ['a', 'b', 'c'] (iteration order is not guaranteed)
|
||
*/
|
||
function keysIn(object) {
|
||
if (object == null) {
|
||
return [];
|
||
}
|
||
if (!isObject(object)) {
|
||
object = Object(object);
|
||
}
|
||
var length = object.length;
|
||
length = (length && isLength(length) &&
|
||
(isArray(object) || isArguments(object)) && length) || 0;
|
||
|
||
var Ctor = object.constructor,
|
||
index = -1,
|
||
isProto = typeof Ctor == 'function' && Ctor.prototype === object,
|
||
result = Array(length),
|
||
skipIndexes = length > 0;
|
||
|
||
while (++index < length) {
|
||
result[index] = (index + '');
|
||
}
|
||
for (var key in object) {
|
||
if (!(skipIndexes && isIndex(key, length)) &&
|
||
!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
|
||
result.push(key);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = keysIn;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/isIndex":110,"../internal/isLength":113,"../lang/isArguments":119,"../lang/isArray":120,"../lang/isObject":123}],129:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/object/mapValues.js", module);
|
||
(function(){
|
||
var createObjectMapper = require('../internal/createObjectMapper');
|
||
|
||
/**
|
||
* Creates an object with the same keys as `object` and values generated by
|
||
* running each own enumerable property of `object` through `iteratee`. The
|
||
* iteratee function is bound to `thisArg` and invoked with three arguments:
|
||
* (value, key, object).
|
||
*
|
||
* If a property name is provided for `iteratee` the created `_.property`
|
||
* style callback returns the property value of the given element.
|
||
*
|
||
* If a value is also provided for `thisArg` the created `_.matchesProperty`
|
||
* style callback returns `true` for elements that have a matching property
|
||
* value, else `false`.
|
||
*
|
||
* If an object is provided for `iteratee` the created `_.matches` style
|
||
* callback returns `true` for elements that have the properties of the given
|
||
* object, else `false`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Object
|
||
* @param {Object} object The object to iterate over.
|
||
* @param {Function|Object|string} [iteratee=_.identity] The function invoked
|
||
* per iteration.
|
||
* @param {*} [thisArg] The `this` binding of `iteratee`.
|
||
* @returns {Object} Returns the new mapped object.
|
||
* @example
|
||
*
|
||
* _.mapValues({ 'a': 1, 'b': 2 }, function(n) {
|
||
* return n * 3;
|
||
* });
|
||
* // => { 'a': 3, 'b': 6 }
|
||
*
|
||
* var users = {
|
||
* 'fred': { 'user': 'fred', 'age': 40 },
|
||
* 'pebbles': { 'user': 'pebbles', 'age': 1 }
|
||
* };
|
||
*
|
||
* // using the `_.property` callback shorthand
|
||
* _.mapValues(users, 'age');
|
||
* // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
|
||
*/
|
||
var mapValues = createObjectMapper();
|
||
|
||
module.exports = mapValues;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/createObjectMapper":102}],130:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/object/pairs.js", module);
|
||
(function(){
|
||
var keys = require('./keys'),
|
||
toObject = require('../internal/toObject');
|
||
|
||
/**
|
||
* Creates a two dimensional array of the key-value pairs for `object`,
|
||
* e.g. `[[key1, value1], [key2, value2]]`.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Object
|
||
* @param {Object} object The object to query.
|
||
* @returns {Array} Returns the new array of key-value pairs.
|
||
* @example
|
||
*
|
||
* _.pairs({ 'barney': 36, 'fred': 40 });
|
||
* // => [['barney', 36], ['fred', 40]] (iteration order is not guaranteed)
|
||
*/
|
||
function pairs(object) {
|
||
object = toObject(object);
|
||
|
||
var index = -1,
|
||
props = keys(object),
|
||
length = props.length,
|
||
result = Array(length);
|
||
|
||
while (++index < length) {
|
||
var key = props[index];
|
||
result[index] = [key, object[key]];
|
||
}
|
||
return result;
|
||
}
|
||
|
||
module.exports = pairs;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/toObject":117,"./keys":127}],131:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/utility/identity.js", module);
|
||
(function(){
|
||
/**
|
||
* This method returns the first argument provided to it.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Utility
|
||
* @param {*} value Any value.
|
||
* @returns {*} Returns `value`.
|
||
* @example
|
||
*
|
||
* var object = { 'user': 'fred' };
|
||
*
|
||
* _.identity(object) === object;
|
||
* // => true
|
||
*/
|
||
function identity(value) {
|
||
return value;
|
||
}
|
||
|
||
module.exports = identity;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],132:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/lodash/utility/property.js", module);
|
||
(function(){
|
||
var baseProperty = require('../internal/baseProperty'),
|
||
basePropertyDeep = require('../internal/basePropertyDeep'),
|
||
isKey = require('../internal/isKey');
|
||
|
||
/**
|
||
* Creates a function that returns the property value at `path` on a
|
||
* given object.
|
||
*
|
||
* @static
|
||
* @memberOf _
|
||
* @category Utility
|
||
* @param {Array|string} path The path of the property to get.
|
||
* @returns {Function} Returns the new function.
|
||
* @example
|
||
*
|
||
* var objects = [
|
||
* { 'a': { 'b': { 'c': 2 } } },
|
||
* { 'a': { 'b': { 'c': 1 } } }
|
||
* ];
|
||
*
|
||
* _.map(objects, _.property('a.b.c'));
|
||
* // => [2, 1]
|
||
*
|
||
* _.pluck(_.sortBy(objects, _.property(['a', 'b', 'c'])), 'a.b.c');
|
||
* // => [1, 2]
|
||
*/
|
||
function property(path) {
|
||
return isKey(path) ? baseProperty(path) : basePropertyDeep(path);
|
||
}
|
||
|
||
module.exports = property;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"../internal/baseProperty":91,"../internal/basePropertyDeep":92,"../internal/isKey":112}],133:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/ms/index.js", module);
|
||
(function(){
|
||
/**
|
||
* Helpers.
|
||
*/
|
||
|
||
var s = 1000;
|
||
var m = s * 60;
|
||
var h = m * 60;
|
||
var d = h * 24;
|
||
var y = d * 365.25;
|
||
|
||
/**
|
||
* Parse or format the given `val`.
|
||
*
|
||
* Options:
|
||
*
|
||
* - `long` verbose formatting [false]
|
||
*
|
||
* @param {String|Number} val
|
||
* @param {Object} options
|
||
* @return {String|Number}
|
||
* @api public
|
||
*/
|
||
|
||
module.exports = function(val, options){
|
||
options = options || {};
|
||
if ('string' == typeof val) return parse(val);
|
||
return options.long
|
||
? long(val)
|
||
: short(val);
|
||
};
|
||
|
||
/**
|
||
* Parse the given `str` and return milliseconds.
|
||
*
|
||
* @param {String} str
|
||
* @return {Number}
|
||
* @api private
|
||
*/
|
||
|
||
function parse(str) {
|
||
str = '' + str;
|
||
if (str.length > 10000) return;
|
||
var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str);
|
||
if (!match) return;
|
||
var n = parseFloat(match[1]);
|
||
var type = (match[2] || 'ms').toLowerCase();
|
||
switch (type) {
|
||
case 'years':
|
||
case 'year':
|
||
case 'yrs':
|
||
case 'yr':
|
||
case 'y':
|
||
return n * y;
|
||
case 'days':
|
||
case 'day':
|
||
case 'd':
|
||
return n * d;
|
||
case 'hours':
|
||
case 'hour':
|
||
case 'hrs':
|
||
case 'hr':
|
||
case 'h':
|
||
return n * h;
|
||
case 'minutes':
|
||
case 'minute':
|
||
case 'mins':
|
||
case 'min':
|
||
case 'm':
|
||
return n * m;
|
||
case 'seconds':
|
||
case 'second':
|
||
case 'secs':
|
||
case 'sec':
|
||
case 's':
|
||
return n * s;
|
||
case 'milliseconds':
|
||
case 'millisecond':
|
||
case 'msecs':
|
||
case 'msec':
|
||
case 'ms':
|
||
return n;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Short format for `ms`.
|
||
*
|
||
* @param {Number} ms
|
||
* @return {String}
|
||
* @api private
|
||
*/
|
||
|
||
function short(ms) {
|
||
if (ms >= d) return Math.round(ms / d) + 'd';
|
||
if (ms >= h) return Math.round(ms / h) + 'h';
|
||
if (ms >= m) return Math.round(ms / m) + 'm';
|
||
if (ms >= s) return Math.round(ms / s) + 's';
|
||
return ms + 'ms';
|
||
}
|
||
|
||
/**
|
||
* Long format for `ms`.
|
||
*
|
||
* @param {Number} ms
|
||
* @return {String}
|
||
* @api private
|
||
*/
|
||
|
||
function long(ms) {
|
||
return plural(ms, d, 'day')
|
||
|| plural(ms, h, 'hour')
|
||
|| plural(ms, m, 'minute')
|
||
|| plural(ms, s, 'second')
|
||
|| ms + ' ms';
|
||
}
|
||
|
||
/**
|
||
* Pluralization helper.
|
||
*/
|
||
|
||
function plural(ms, n, name) {
|
||
if (ms < n) return;
|
||
if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name;
|
||
return Math.ceil(ms / n) + ' ' + name + 's';
|
||
}
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],134:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/parsejson/index.js", module);
|
||
(function(){
|
||
(function (global){
|
||
/**
|
||
* JSON parse.
|
||
*
|
||
* @see Based on jQuery#parseJSON (MIT) and JSON2
|
||
* @api private
|
||
*/
|
||
|
||
var rvalidchars = /^[\],:{}\s]*$/;
|
||
var rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g;
|
||
var rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g;
|
||
var rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g;
|
||
var rtrimLeft = /^\s+/;
|
||
var rtrimRight = /\s+$/;
|
||
|
||
module.exports = function parsejson(data) {
|
||
if ('string' != typeof data || !data) {
|
||
return null;
|
||
}
|
||
|
||
data = data.replace(rtrimLeft, '').replace(rtrimRight, '');
|
||
|
||
// Attempt to parse using the native JSON parser first
|
||
if (global.JSON && JSON.parse) {
|
||
return JSON.parse(data);
|
||
}
|
||
|
||
if (rvalidchars.test(data.replace(rvalidescape, '@')
|
||
.replace(rvalidtokens, ']')
|
||
.replace(rvalidbraces, ''))) {
|
||
return (new Function('return ' + data))();
|
||
}
|
||
};
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],135:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/parseqs/index.js", module);
|
||
(function(){
|
||
/**
|
||
* Compiles a querystring
|
||
* Returns string representation of the object
|
||
*
|
||
* @param {Object}
|
||
* @api private
|
||
*/
|
||
|
||
exports.encode = function (obj) {
|
||
var str = '';
|
||
|
||
for (var i in obj) {
|
||
if (obj.hasOwnProperty(i)) {
|
||
if (str.length) str += '&';
|
||
str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);
|
||
}
|
||
}
|
||
|
||
return str;
|
||
};
|
||
|
||
/**
|
||
* Parses a simple querystring into an object
|
||
*
|
||
* @param {String} qs
|
||
* @api private
|
||
*/
|
||
|
||
exports.decode = function(qs){
|
||
var qry = {};
|
||
var pairs = qs.split('&');
|
||
for (var i = 0, l = pairs.length; i < l; i++) {
|
||
var pair = pairs[i].split('=');
|
||
qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
|
||
}
|
||
return qry;
|
||
};
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],136:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/parseuri/index.js", module);
|
||
(function(){
|
||
/**
|
||
* Parses an URI
|
||
*
|
||
* @author Steven Levithan <stevenlevithan.com> (MIT license)
|
||
* @api private
|
||
*/
|
||
|
||
var re = /^(?:(?![^:@]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
|
||
|
||
var parts = [
|
||
'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'
|
||
];
|
||
|
||
module.exports = function parseuri(str) {
|
||
var src = str,
|
||
b = str.indexOf('['),
|
||
e = str.indexOf(']');
|
||
|
||
if (b != -1 && e != -1) {
|
||
str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);
|
||
}
|
||
|
||
var m = re.exec(str || ''),
|
||
uri = {},
|
||
i = 14;
|
||
|
||
while (i--) {
|
||
uri[parts[i]] = m[i] || '';
|
||
}
|
||
|
||
if (b != -1 && e != -1) {
|
||
uri.source = src;
|
||
uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');
|
||
uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');
|
||
uri.ipv6uri = true;
|
||
}
|
||
|
||
return uri;
|
||
};
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],137:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/process/browser.js", module);
|
||
(function(){
|
||
// shim for using process in browser
|
||
|
||
var process = module.exports = {};
|
||
var queue = [];
|
||
var draining = false;
|
||
var currentQueue;
|
||
var queueIndex = -1;
|
||
|
||
function cleanUpNextTick() {
|
||
draining = false;
|
||
if (currentQueue.length) {
|
||
queue = currentQueue.concat(queue);
|
||
} else {
|
||
queueIndex = -1;
|
||
}
|
||
if (queue.length) {
|
||
drainQueue();
|
||
}
|
||
}
|
||
|
||
function drainQueue() {
|
||
if (draining) {
|
||
return;
|
||
}
|
||
var timeout = setTimeout(cleanUpNextTick);
|
||
draining = true;
|
||
|
||
var len = queue.length;
|
||
while(len) {
|
||
currentQueue = queue;
|
||
queue = [];
|
||
while (++queueIndex < len) {
|
||
if (currentQueue) {
|
||
currentQueue[queueIndex].run();
|
||
}
|
||
}
|
||
queueIndex = -1;
|
||
len = queue.length;
|
||
}
|
||
currentQueue = null;
|
||
draining = false;
|
||
clearTimeout(timeout);
|
||
}
|
||
|
||
process.nextTick = function (fun) {
|
||
var args = new Array(arguments.length - 1);
|
||
if (arguments.length > 1) {
|
||
for (var i = 1; i < arguments.length; i++) {
|
||
args[i - 1] = arguments[i];
|
||
}
|
||
}
|
||
queue.push(new Item(fun, args));
|
||
if (queue.length === 1 && !draining) {
|
||
setTimeout(drainQueue, 0);
|
||
}
|
||
};
|
||
|
||
// v8 likes predictible objects
|
||
function Item(fun, array) {
|
||
this.fun = fun;
|
||
this.array = array;
|
||
}
|
||
Item.prototype.run = function () {
|
||
this.fun.apply(null, this.array);
|
||
};
|
||
process.title = 'browser';
|
||
process.browser = true;
|
||
process.env = {};
|
||
process.argv = [];
|
||
process.version = ''; // empty string to avoid regexp issues
|
||
process.versions = {};
|
||
|
||
function noop() {}
|
||
|
||
process.on = noop;
|
||
process.addListener = noop;
|
||
process.once = noop;
|
||
process.off = noop;
|
||
process.removeListener = noop;
|
||
process.removeAllListeners = noop;
|
||
process.emit = noop;
|
||
|
||
process.binding = function (name) {
|
||
throw new Error('process.binding is not supported');
|
||
};
|
||
|
||
process.cwd = function () { return '/' };
|
||
process.chdir = function (dir) {
|
||
throw new Error('process.chdir is not supported');
|
||
};
|
||
process.umask = function() { return 0; };
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],138:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/socket.io-client/lib/index.js", module);
|
||
(function(){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var url = require('./url');
|
||
var parser = require('socket.io-parser');
|
||
var Manager = require('./manager');
|
||
var debug = require('debug')('socket.io-client');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = exports = lookup;
|
||
|
||
/**
|
||
* Managers cache.
|
||
*/
|
||
|
||
var cache = exports.managers = {};
|
||
|
||
/**
|
||
* Looks up an existing `Manager` for multiplexing.
|
||
* If the user summons:
|
||
*
|
||
* `io('http://localhost/a');`
|
||
* `io('http://localhost/b');`
|
||
*
|
||
* We reuse the existing instance based on same scheme/port/host,
|
||
* and we initialize sockets for each namespace.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
function lookup(uri, opts) {
|
||
if (typeof uri == 'object') {
|
||
opts = uri;
|
||
uri = undefined;
|
||
}
|
||
|
||
opts = opts || {};
|
||
|
||
var parsed = url(uri);
|
||
var source = parsed.source;
|
||
var id = parsed.id;
|
||
var path = parsed.path;
|
||
var sameNamespace = cache[id] && path in cache[id].nsps;
|
||
var newConnection = opts.forceNew || opts['force new connection'] ||
|
||
false === opts.multiplex || sameNamespace;
|
||
|
||
var io;
|
||
|
||
if (newConnection) {
|
||
debug('ignoring socket cache for %s', source);
|
||
io = Manager(source, opts);
|
||
} else {
|
||
if (!cache[id]) {
|
||
debug('new io instance for %s', source);
|
||
cache[id] = Manager(source, opts);
|
||
}
|
||
io = cache[id];
|
||
}
|
||
|
||
return io.socket(parsed.path);
|
||
}
|
||
|
||
/**
|
||
* Protocol version.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.protocol = parser.protocol;
|
||
|
||
/**
|
||
* `connect`.
|
||
*
|
||
* @param {String} uri
|
||
* @api public
|
||
*/
|
||
|
||
exports.connect = lookup;
|
||
|
||
/**
|
||
* Expose constructors for standalone build.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.Manager = require('./manager');
|
||
exports.Socket = require('./socket');
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./manager":139,"./socket":141,"./url":142,"debug":46,"socket.io-parser":145}],139:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/socket.io-client/lib/manager.js", module);
|
||
(function(){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var eio = require('engine.io-client');
|
||
var Socket = require('./socket');
|
||
var Emitter = require('component-emitter');
|
||
var parser = require('socket.io-parser');
|
||
var on = require('./on');
|
||
var bind = require('component-bind');
|
||
var debug = require('debug')('socket.io-client:manager');
|
||
var indexOf = require('indexof');
|
||
var Backoff = require('backo2');
|
||
|
||
/**
|
||
* IE6+ hasOwnProperty
|
||
*/
|
||
|
||
var has = Object.prototype.hasOwnProperty;
|
||
|
||
/**
|
||
* Module exports
|
||
*/
|
||
|
||
module.exports = Manager;
|
||
|
||
/**
|
||
* `Manager` constructor.
|
||
*
|
||
* @param {String} engine instance or engine uri/opts
|
||
* @param {Object} options
|
||
* @api public
|
||
*/
|
||
|
||
function Manager(uri, opts){
|
||
if (!(this instanceof Manager)) return new Manager(uri, opts);
|
||
if (uri && ('object' == typeof uri)) {
|
||
opts = uri;
|
||
uri = undefined;
|
||
}
|
||
opts = opts || {};
|
||
|
||
opts.path = opts.path || '/socket.io';
|
||
this.nsps = {};
|
||
this.subs = [];
|
||
this.opts = opts;
|
||
this.reconnection(opts.reconnection !== false);
|
||
this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
|
||
this.reconnectionDelay(opts.reconnectionDelay || 1000);
|
||
this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);
|
||
this.randomizationFactor(opts.randomizationFactor || 0.5);
|
||
this.backoff = new Backoff({
|
||
min: this.reconnectionDelay(),
|
||
max: this.reconnectionDelayMax(),
|
||
jitter: this.randomizationFactor()
|
||
});
|
||
this.timeout(null == opts.timeout ? 20000 : opts.timeout);
|
||
this.readyState = 'closed';
|
||
this.uri = uri;
|
||
this.connecting = [];
|
||
this.lastPing = null;
|
||
this.encoding = false;
|
||
this.packetBuffer = [];
|
||
this.encoder = new parser.Encoder();
|
||
this.decoder = new parser.Decoder();
|
||
this.autoConnect = opts.autoConnect !== false;
|
||
if (this.autoConnect) this.open();
|
||
}
|
||
|
||
/**
|
||
* Propagate given event to sockets and emit on `this`
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.emitAll = function() {
|
||
this.emit.apply(this, arguments);
|
||
for (var nsp in this.nsps) {
|
||
if (has.call(this.nsps, nsp)) {
|
||
this.nsps[nsp].emit.apply(this.nsps[nsp], arguments);
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Update `socket.id` of all sockets
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.updateSocketIds = function(){
|
||
for (var nsp in this.nsps) {
|
||
if (has.call(this.nsps, nsp)) {
|
||
this.nsps[nsp].id = this.engine.id;
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/
|
||
|
||
Emitter(Manager.prototype);
|
||
|
||
/**
|
||
* Sets the `reconnection` config.
|
||
*
|
||
* @param {Boolean} true/false if it should automatically reconnect
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/
|
||
|
||
Manager.prototype.reconnection = function(v){
|
||
if (!arguments.length) return this._reconnection;
|
||
this._reconnection = !!v;
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sets the reconnection attempts config.
|
||
*
|
||
* @param {Number} max reconnection attempts before giving up
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/
|
||
|
||
Manager.prototype.reconnectionAttempts = function(v){
|
||
if (!arguments.length) return this._reconnectionAttempts;
|
||
this._reconnectionAttempts = v;
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sets the delay between reconnections.
|
||
*
|
||
* @param {Number} delay
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/
|
||
|
||
Manager.prototype.reconnectionDelay = function(v){
|
||
if (!arguments.length) return this._reconnectionDelay;
|
||
this._reconnectionDelay = v;
|
||
this.backoff && this.backoff.setMin(v);
|
||
return this;
|
||
};
|
||
|
||
Manager.prototype.randomizationFactor = function(v){
|
||
if (!arguments.length) return this._randomizationFactor;
|
||
this._randomizationFactor = v;
|
||
this.backoff && this.backoff.setJitter(v);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sets the maximum delay between reconnections.
|
||
*
|
||
* @param {Number} delay
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/
|
||
|
||
Manager.prototype.reconnectionDelayMax = function(v){
|
||
if (!arguments.length) return this._reconnectionDelayMax;
|
||
this._reconnectionDelayMax = v;
|
||
this.backoff && this.backoff.setMax(v);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sets the connection timeout. `false` to disable
|
||
*
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/
|
||
|
||
Manager.prototype.timeout = function(v){
|
||
if (!arguments.length) return this._timeout;
|
||
this._timeout = v;
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Starts trying to reconnect if reconnection is enabled and we have not
|
||
* started reconnecting yet
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.maybeReconnectOnOpen = function() {
|
||
// Only try to reconnect if it's the first time we're connecting
|
||
if (!this.reconnecting && this._reconnection && this.backoff.attempts === 0) {
|
||
// keeps reconnection from firing twice for the same reconnection loop
|
||
this.reconnect();
|
||
}
|
||
};
|
||
|
||
|
||
/**
|
||
* Sets the current transport `socket`.
|
||
*
|
||
* @param {Function} optional, callback
|
||
* @return {Manager} self
|
||
* @api public
|
||
*/
|
||
|
||
Manager.prototype.open =
|
||
Manager.prototype.connect = function(fn){
|
||
debug('readyState %s', this.readyState);
|
||
if (~this.readyState.indexOf('open')) return this;
|
||
|
||
debug('opening %s', this.uri);
|
||
this.engine = eio(this.uri, this.opts);
|
||
var socket = this.engine;
|
||
var self = this;
|
||
this.readyState = 'opening';
|
||
this.skipReconnect = false;
|
||
|
||
// emit `open`
|
||
var openSub = on(socket, 'open', function() {
|
||
self.onopen();
|
||
fn && fn();
|
||
});
|
||
|
||
// emit `connect_error`
|
||
var errorSub = on(socket, 'error', function(data){
|
||
debug('connect_error');
|
||
self.cleanup();
|
||
self.readyState = 'closed';
|
||
self.emitAll('connect_error', data);
|
||
if (fn) {
|
||
var err = new Error('Connection error');
|
||
err.data = data;
|
||
fn(err);
|
||
} else {
|
||
// Only do this if there is no fn to handle the error
|
||
self.maybeReconnectOnOpen();
|
||
}
|
||
});
|
||
|
||
// emit `connect_timeout`
|
||
if (false !== this._timeout) {
|
||
var timeout = this._timeout;
|
||
debug('connect attempt will timeout after %d', timeout);
|
||
|
||
// set timer
|
||
var timer = setTimeout(function(){
|
||
debug('connect attempt timed out after %d', timeout);
|
||
openSub.destroy();
|
||
socket.close();
|
||
socket.emit('error', 'timeout');
|
||
self.emitAll('connect_timeout', timeout);
|
||
}, timeout);
|
||
|
||
this.subs.push({
|
||
destroy: function(){
|
||
clearTimeout(timer);
|
||
}
|
||
});
|
||
}
|
||
|
||
this.subs.push(openSub);
|
||
this.subs.push(errorSub);
|
||
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Called upon transport open.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.onopen = function(){
|
||
debug('open');
|
||
|
||
// clear old subs
|
||
this.cleanup();
|
||
|
||
// mark as open
|
||
this.readyState = 'open';
|
||
this.emit('open');
|
||
|
||
// add new subs
|
||
var socket = this.engine;
|
||
this.subs.push(on(socket, 'data', bind(this, 'ondata')));
|
||
this.subs.push(on(socket, 'ping', bind(this, 'onping')));
|
||
this.subs.push(on(socket, 'pong', bind(this, 'onpong')));
|
||
this.subs.push(on(socket, 'error', bind(this, 'onerror')));
|
||
this.subs.push(on(socket, 'close', bind(this, 'onclose')));
|
||
this.subs.push(on(this.decoder, 'decoded', bind(this, 'ondecoded')));
|
||
};
|
||
|
||
/**
|
||
* Called upon a ping.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.onping = function(){
|
||
this.lastPing = new Date;
|
||
this.emitAll('ping');
|
||
};
|
||
|
||
/**
|
||
* Called upon a packet.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.onpong = function(){
|
||
this.emitAll('pong', new Date - this.lastPing);
|
||
};
|
||
|
||
/**
|
||
* Called with data.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.ondata = function(data){
|
||
this.decoder.add(data);
|
||
};
|
||
|
||
/**
|
||
* Called when parser fully decodes a packet.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.ondecoded = function(packet) {
|
||
this.emit('packet', packet);
|
||
};
|
||
|
||
/**
|
||
* Called upon socket error.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.onerror = function(err){
|
||
debug('error', err);
|
||
this.emitAll('error', err);
|
||
};
|
||
|
||
/**
|
||
* Creates a new socket for the given `nsp`.
|
||
*
|
||
* @return {Socket}
|
||
* @api public
|
||
*/
|
||
|
||
Manager.prototype.socket = function(nsp){
|
||
var socket = this.nsps[nsp];
|
||
if (!socket) {
|
||
socket = new Socket(this, nsp);
|
||
this.nsps[nsp] = socket;
|
||
var self = this;
|
||
socket.on('connecting', onConnecting);
|
||
socket.on('connect', function(){
|
||
socket.id = self.engine.id;
|
||
});
|
||
|
||
if (this.autoConnect) {
|
||
// manually call here since connecting evnet is fired before listening
|
||
onConnecting();
|
||
}
|
||
}
|
||
|
||
function onConnecting() {
|
||
if (!~indexOf(self.connecting, socket)) {
|
||
self.connecting.push(socket);
|
||
}
|
||
}
|
||
|
||
return socket;
|
||
};
|
||
|
||
/**
|
||
* Called upon a socket close.
|
||
*
|
||
* @param {Socket} socket
|
||
*/
|
||
|
||
Manager.prototype.destroy = function(socket){
|
||
var index = indexOf(this.connecting, socket);
|
||
if (~index) this.connecting.splice(index, 1);
|
||
if (this.connecting.length) return;
|
||
|
||
this.close();
|
||
};
|
||
|
||
/**
|
||
* Writes a packet.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.packet = function(packet){
|
||
debug('writing packet %j', packet);
|
||
var self = this;
|
||
|
||
if (!self.encoding) {
|
||
// encode, then write to engine with result
|
||
self.encoding = true;
|
||
this.encoder.encode(packet, function(encodedPackets) {
|
||
for (var i = 0; i < encodedPackets.length; i++) {
|
||
self.engine.write(encodedPackets[i], packet.options);
|
||
}
|
||
self.encoding = false;
|
||
self.processPacketQueue();
|
||
});
|
||
} else { // add packet to the queue
|
||
self.packetBuffer.push(packet);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* If packet buffer is non-empty, begins encoding the
|
||
* next packet in line.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.processPacketQueue = function() {
|
||
if (this.packetBuffer.length > 0 && !this.encoding) {
|
||
var pack = this.packetBuffer.shift();
|
||
this.packet(pack);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Clean up transport subscriptions and packet buffer.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.cleanup = function(){
|
||
debug('cleanup');
|
||
|
||
var sub;
|
||
while (sub = this.subs.shift()) sub.destroy();
|
||
|
||
this.packetBuffer = [];
|
||
this.encoding = false;
|
||
this.lastPing = null;
|
||
|
||
this.decoder.destroy();
|
||
};
|
||
|
||
/**
|
||
* Close the current socket.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.close =
|
||
Manager.prototype.disconnect = function(){
|
||
debug('disconnect');
|
||
this.skipReconnect = true;
|
||
this.reconnecting = false;
|
||
if ('opening' == this.readyState) {
|
||
// `onclose` will not fire because
|
||
// an open event never happened
|
||
this.cleanup();
|
||
}
|
||
this.backoff.reset();
|
||
this.readyState = 'closed';
|
||
if (this.engine) this.engine.close();
|
||
};
|
||
|
||
/**
|
||
* Called upon engine close.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.onclose = function(reason){
|
||
debug('onclose');
|
||
|
||
this.cleanup();
|
||
this.backoff.reset();
|
||
this.readyState = 'closed';
|
||
this.emit('close', reason);
|
||
|
||
if (this._reconnection && !this.skipReconnect) {
|
||
this.reconnect();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Attempt a reconnection.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.reconnect = function(){
|
||
if (this.reconnecting || this.skipReconnect) return this;
|
||
|
||
var self = this;
|
||
|
||
if (this.backoff.attempts >= this._reconnectionAttempts) {
|
||
debug('reconnect failed');
|
||
this.backoff.reset();
|
||
this.emitAll('reconnect_failed');
|
||
this.reconnecting = false;
|
||
} else {
|
||
var delay = this.backoff.duration();
|
||
debug('will wait %dms before reconnect attempt', delay);
|
||
|
||
this.reconnecting = true;
|
||
var timer = setTimeout(function(){
|
||
if (self.skipReconnect) return;
|
||
|
||
debug('attempting reconnect');
|
||
self.emitAll('reconnect_attempt', self.backoff.attempts);
|
||
self.emitAll('reconnecting', self.backoff.attempts);
|
||
|
||
// check again for the case socket closed in above events
|
||
if (self.skipReconnect) return;
|
||
|
||
self.open(function(err){
|
||
if (err) {
|
||
debug('reconnect attempt error');
|
||
self.reconnecting = false;
|
||
self.reconnect();
|
||
self.emitAll('reconnect_error', err.data);
|
||
} else {
|
||
debug('reconnect success');
|
||
self.onreconnect();
|
||
}
|
||
});
|
||
}, delay);
|
||
|
||
this.subs.push({
|
||
destroy: function(){
|
||
clearTimeout(timer);
|
||
}
|
||
});
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Called upon successful reconnect.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.onreconnect = function(){
|
||
var attempt = this.backoff.attempts;
|
||
this.reconnecting = false;
|
||
this.backoff.reset();
|
||
this.updateSocketIds();
|
||
this.emitAll('reconnect', attempt);
|
||
};
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./on":140,"./socket":141,"backo2":6,"component-bind":13,"component-emitter":143,"debug":46,"engine.io-client":48,"indexof":63,"socket.io-parser":145}],140:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/socket.io-client/lib/on.js", module);
|
||
(function(){
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = on;
|
||
|
||
/**
|
||
* Helper for subscriptions.
|
||
*
|
||
* @param {Object|EventEmitter} obj with `Emitter` mixin or `EventEmitter`
|
||
* @param {String} event name
|
||
* @param {Function} callback
|
||
* @api public
|
||
*/
|
||
|
||
function on(obj, ev, fn) {
|
||
obj.on(ev, fn);
|
||
return {
|
||
destroy: function(){
|
||
obj.removeListener(ev, fn);
|
||
}
|
||
};
|
||
}
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],141:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/socket.io-client/lib/socket.js", module);
|
||
(function(){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var parser = require('socket.io-parser');
|
||
var Emitter = require('component-emitter');
|
||
var toArray = require('to-array');
|
||
var on = require('./on');
|
||
var bind = require('component-bind');
|
||
var debug = require('debug')('socket.io-client:socket');
|
||
var hasBin = require('has-binary');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = exports = Socket;
|
||
|
||
/**
|
||
* Internal events (blacklisted).
|
||
* These events can't be emitted by the user.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
var events = {
|
||
connect: 1,
|
||
connect_error: 1,
|
||
connect_timeout: 1,
|
||
connecting: 1,
|
||
disconnect: 1,
|
||
error: 1,
|
||
reconnect: 1,
|
||
reconnect_attempt: 1,
|
||
reconnect_failed: 1,
|
||
reconnect_error: 1,
|
||
reconnecting: 1,
|
||
ping: 1,
|
||
pong: 1
|
||
};
|
||
|
||
/**
|
||
* Shortcut to `Emitter#emit`.
|
||
*/
|
||
|
||
var emit = Emitter.prototype.emit;
|
||
|
||
/**
|
||
* `Socket` constructor.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
function Socket(io, nsp){
|
||
this.io = io;
|
||
this.nsp = nsp;
|
||
this.json = this; // compat
|
||
this.ids = 0;
|
||
this.acks = {};
|
||
this.receiveBuffer = [];
|
||
this.sendBuffer = [];
|
||
this.connected = false;
|
||
this.disconnected = true;
|
||
if (this.io.autoConnect) this.open();
|
||
}
|
||
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/
|
||
|
||
Emitter(Socket.prototype);
|
||
|
||
/**
|
||
* Subscribe to open, close and packet events
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.subEvents = function() {
|
||
if (this.subs) return;
|
||
|
||
var io = this.io;
|
||
this.subs = [
|
||
on(io, 'open', bind(this, 'onopen')),
|
||
on(io, 'packet', bind(this, 'onpacket')),
|
||
on(io, 'close', bind(this, 'onclose'))
|
||
];
|
||
};
|
||
|
||
/**
|
||
* "Opens" the socket.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Socket.prototype.open =
|
||
Socket.prototype.connect = function(){
|
||
if (this.connected) return this;
|
||
|
||
this.subEvents();
|
||
this.io.open(); // ensure open
|
||
if ('open' == this.io.readyState) this.onopen();
|
||
this.emit('connecting');
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sends a `message` event.
|
||
*
|
||
* @return {Socket} self
|
||
* @api public
|
||
*/
|
||
|
||
Socket.prototype.send = function(){
|
||
var args = toArray(arguments);
|
||
args.unshift('message');
|
||
this.emit.apply(this, args);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Override `emit`.
|
||
* If the event is in `events`, it's emitted normally.
|
||
*
|
||
* @param {String} event name
|
||
* @return {Socket} self
|
||
* @api public
|
||
*/
|
||
|
||
Socket.prototype.emit = function(ev){
|
||
if (events.hasOwnProperty(ev)) {
|
||
emit.apply(this, arguments);
|
||
return this;
|
||
}
|
||
|
||
var args = toArray(arguments);
|
||
var parserType = parser.EVENT; // default
|
||
if (hasBin(args)) { parserType = parser.BINARY_EVENT; } // binary
|
||
var packet = { type: parserType, data: args };
|
||
|
||
packet.options = {};
|
||
packet.options.compress = !this.flags || false !== this.flags.compress;
|
||
|
||
// event ack callback
|
||
if ('function' == typeof args[args.length - 1]) {
|
||
debug('emitting packet with ack id %d', this.ids);
|
||
this.acks[this.ids] = args.pop();
|
||
packet.id = this.ids++;
|
||
}
|
||
|
||
if (this.connected) {
|
||
this.packet(packet);
|
||
} else {
|
||
this.sendBuffer.push(packet);
|
||
}
|
||
|
||
delete this.flags;
|
||
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sends a packet.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.packet = function(packet){
|
||
packet.nsp = this.nsp;
|
||
this.io.packet(packet);
|
||
};
|
||
|
||
/**
|
||
* Called upon engine `open`.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onopen = function(){
|
||
debug('transport is open - connecting');
|
||
|
||
// write connect packet if necessary
|
||
if ('/' != this.nsp) {
|
||
this.packet({ type: parser.CONNECT });
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Called upon engine `close`.
|
||
*
|
||
* @param {String} reason
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onclose = function(reason){
|
||
debug('close (%s)', reason);
|
||
this.connected = false;
|
||
this.disconnected = true;
|
||
delete this.id;
|
||
this.emit('disconnect', reason);
|
||
};
|
||
|
||
/**
|
||
* Called with socket packet.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onpacket = function(packet){
|
||
if (packet.nsp != this.nsp) return;
|
||
|
||
switch (packet.type) {
|
||
case parser.CONNECT:
|
||
this.onconnect();
|
||
break;
|
||
|
||
case parser.EVENT:
|
||
this.onevent(packet);
|
||
break;
|
||
|
||
case parser.BINARY_EVENT:
|
||
this.onevent(packet);
|
||
break;
|
||
|
||
case parser.ACK:
|
||
this.onack(packet);
|
||
break;
|
||
|
||
case parser.BINARY_ACK:
|
||
this.onack(packet);
|
||
break;
|
||
|
||
case parser.DISCONNECT:
|
||
this.ondisconnect();
|
||
break;
|
||
|
||
case parser.ERROR:
|
||
this.emit('error', packet.data);
|
||
break;
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Called upon a server event.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onevent = function(packet){
|
||
var args = packet.data || [];
|
||
debug('emitting event %j', args);
|
||
|
||
if (null != packet.id) {
|
||
debug('attaching ack callback to event');
|
||
args.push(this.ack(packet.id));
|
||
}
|
||
|
||
if (this.connected) {
|
||
emit.apply(this, args);
|
||
} else {
|
||
this.receiveBuffer.push(args);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Produces an ack callback to emit with an event.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.ack = function(id){
|
||
var self = this;
|
||
var sent = false;
|
||
return function(){
|
||
// prevent double callbacks
|
||
if (sent) return;
|
||
sent = true;
|
||
var args = toArray(arguments);
|
||
debug('sending ack %j', args);
|
||
|
||
var type = hasBin(args) ? parser.BINARY_ACK : parser.ACK;
|
||
self.packet({
|
||
type: type,
|
||
id: id,
|
||
data: args
|
||
});
|
||
};
|
||
};
|
||
|
||
/**
|
||
* Called upon a server acknowlegement.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onack = function(packet){
|
||
var ack = this.acks[packet.id];
|
||
if ('function' == typeof ack) {
|
||
debug('calling ack %s with %j', packet.id, packet.data);
|
||
ack.apply(this, packet.data);
|
||
delete this.acks[packet.id];
|
||
} else {
|
||
debug('bad ack %s', packet.id);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Called upon server connect.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onconnect = function(){
|
||
this.connected = true;
|
||
this.disconnected = false;
|
||
this.emit('connect');
|
||
this.emitBuffered();
|
||
};
|
||
|
||
/**
|
||
* Emit buffered events (received and emitted).
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.emitBuffered = function(){
|
||
var i;
|
||
for (i = 0; i < this.receiveBuffer.length; i++) {
|
||
emit.apply(this, this.receiveBuffer[i]);
|
||
}
|
||
this.receiveBuffer = [];
|
||
|
||
for (i = 0; i < this.sendBuffer.length; i++) {
|
||
this.packet(this.sendBuffer[i]);
|
||
}
|
||
this.sendBuffer = [];
|
||
};
|
||
|
||
/**
|
||
* Called upon server disconnect.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.ondisconnect = function(){
|
||
debug('server disconnect (%s)', this.nsp);
|
||
this.destroy();
|
||
this.onclose('io server disconnect');
|
||
};
|
||
|
||
/**
|
||
* Called upon forced client/server side disconnections,
|
||
* this method ensures the manager stops tracking us and
|
||
* that reconnections don't get triggered for this.
|
||
*
|
||
* @api private.
|
||
*/
|
||
|
||
Socket.prototype.destroy = function(){
|
||
if (this.subs) {
|
||
// clean subscriptions to avoid reconnections
|
||
for (var i = 0; i < this.subs.length; i++) {
|
||
this.subs[i].destroy();
|
||
}
|
||
this.subs = null;
|
||
}
|
||
|
||
this.io.destroy(this);
|
||
};
|
||
|
||
/**
|
||
* Disconnects the socket manually.
|
||
*
|
||
* @return {Socket} self
|
||
* @api public
|
||
*/
|
||
|
||
Socket.prototype.close =
|
||
Socket.prototype.disconnect = function(){
|
||
if (this.connected) {
|
||
debug('performing disconnect (%s)', this.nsp);
|
||
this.packet({ type: parser.DISCONNECT });
|
||
}
|
||
|
||
// remove socket from pool
|
||
this.destroy();
|
||
|
||
if (this.connected) {
|
||
// fire events
|
||
this.onclose('io client disconnect');
|
||
}
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sets the compress flag.
|
||
*
|
||
* @param {Boolean} if `true`, compresses the sending data
|
||
* @return {Socket} self
|
||
* @api public
|
||
*/
|
||
|
||
Socket.prototype.compress = function(compress){
|
||
this.flags = this.flags || {};
|
||
this.flags.compress = compress;
|
||
return this;
|
||
};
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./on":140,"component-bind":13,"component-emitter":143,"debug":46,"has-binary":61,"socket.io-parser":145,"to-array":148}],142:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/socket.io-client/lib/url.js", module);
|
||
(function(){
|
||
(function (global){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var parseuri = require('parseuri');
|
||
var debug = require('debug')('socket.io-client:url');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = url;
|
||
|
||
/**
|
||
* URL parser.
|
||
*
|
||
* @param {String} url
|
||
* @param {Object} An object meant to mimic window.location.
|
||
* Defaults to window.location.
|
||
* @api public
|
||
*/
|
||
|
||
function url(uri, loc){
|
||
var obj = uri;
|
||
|
||
// default to window.location
|
||
var loc = loc || global.location;
|
||
if (null == uri) uri = loc.protocol + '//' + loc.host;
|
||
|
||
// relative path support
|
||
if ('string' == typeof uri) {
|
||
if ('/' == uri.charAt(0)) {
|
||
if ('/' == uri.charAt(1)) {
|
||
uri = loc.protocol + uri;
|
||
} else {
|
||
uri = loc.host + uri;
|
||
}
|
||
}
|
||
|
||
if (!/^(https?|wss?):\/\//.test(uri)) {
|
||
debug('protocol-less url %s', uri);
|
||
if ('undefined' != typeof loc) {
|
||
uri = loc.protocol + '//' + uri;
|
||
} else {
|
||
uri = 'https://' + uri;
|
||
}
|
||
}
|
||
|
||
// parse
|
||
debug('parse %s', uri);
|
||
obj = parseuri(uri);
|
||
}
|
||
|
||
// make sure we treat `localhost:80` and `localhost` equally
|
||
if (!obj.port) {
|
||
if (/^(http|ws)$/.test(obj.protocol)) {
|
||
obj.port = '80';
|
||
}
|
||
else if (/^(http|ws)s$/.test(obj.protocol)) {
|
||
obj.port = '443';
|
||
}
|
||
}
|
||
|
||
obj.path = obj.path || '/';
|
||
|
||
var ipv6 = obj.host.indexOf(':') !== -1;
|
||
var host = ipv6 ? '[' + obj.host + ']' : obj.host;
|
||
|
||
// define unique id
|
||
obj.id = obj.protocol + '://' + host + ':' + obj.port;
|
||
// define href
|
||
obj.href = obj.protocol + '://' + host + (loc && loc.port == obj.port ? '' : (':' + obj.port));
|
||
|
||
return obj;
|
||
}
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"debug":46,"parseuri":136}],143:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/socket.io-client/node_modules/component-emitter/index.js", module);
|
||
(function(){
|
||
|
||
/**
|
||
* Expose `Emitter`.
|
||
*/
|
||
|
||
module.exports = Emitter;
|
||
|
||
/**
|
||
* Initialize a new `Emitter`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
function Emitter(obj) {
|
||
if (obj) return mixin(obj);
|
||
};
|
||
|
||
/**
|
||
* Mixin the emitter properties.
|
||
*
|
||
* @param {Object} obj
|
||
* @return {Object}
|
||
* @api private
|
||
*/
|
||
|
||
function mixin(obj) {
|
||
for (var key in Emitter.prototype) {
|
||
obj[key] = Emitter.prototype[key];
|
||
}
|
||
return obj;
|
||
}
|
||
|
||
/**
|
||
* Listen on the given `event` with `fn`.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
* @return {Emitter}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.on =
|
||
Emitter.prototype.addEventListener = function(event, fn){
|
||
this._callbacks = this._callbacks || {};
|
||
(this._callbacks['$' + event] = this._callbacks['$' + event] || [])
|
||
.push(fn);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Adds an `event` listener that will be invoked a single
|
||
* time then automatically removed.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
* @return {Emitter}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.once = function(event, fn){
|
||
function on() {
|
||
this.off(event, on);
|
||
fn.apply(this, arguments);
|
||
}
|
||
|
||
on.fn = fn;
|
||
this.on(event, on);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Remove the given callback for `event` or all
|
||
* registered callbacks.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
* @return {Emitter}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.off =
|
||
Emitter.prototype.removeListener =
|
||
Emitter.prototype.removeAllListeners =
|
||
Emitter.prototype.removeEventListener = function(event, fn){
|
||
this._callbacks = this._callbacks || {};
|
||
|
||
// all
|
||
if (0 == arguments.length) {
|
||
this._callbacks = {};
|
||
return this;
|
||
}
|
||
|
||
// specific event
|
||
var callbacks = this._callbacks['$' + event];
|
||
if (!callbacks) return this;
|
||
|
||
// remove all handlers
|
||
if (1 == arguments.length) {
|
||
delete this._callbacks['$' + event];
|
||
return this;
|
||
}
|
||
|
||
// remove specific handler
|
||
var cb;
|
||
for (var i = 0; i < callbacks.length; i++) {
|
||
cb = callbacks[i];
|
||
if (cb === fn || cb.fn === fn) {
|
||
callbacks.splice(i, 1);
|
||
break;
|
||
}
|
||
}
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Emit `event` with the given args.
|
||
*
|
||
* @param {String} event
|
||
* @param {Mixed} ...
|
||
* @return {Emitter}
|
||
*/
|
||
|
||
Emitter.prototype.emit = function(event){
|
||
this._callbacks = this._callbacks || {};
|
||
var args = [].slice.call(arguments, 1)
|
||
, callbacks = this._callbacks['$' + event];
|
||
|
||
if (callbacks) {
|
||
callbacks = callbacks.slice(0);
|
||
for (var i = 0, len = callbacks.length; i < len; ++i) {
|
||
callbacks[i].apply(this, args);
|
||
}
|
||
}
|
||
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Return array of callbacks for `event`.
|
||
*
|
||
* @param {String} event
|
||
* @return {Array}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.listeners = function(event){
|
||
this._callbacks = this._callbacks || {};
|
||
return this._callbacks['$' + event] || [];
|
||
};
|
||
|
||
/**
|
||
* Check if this emitter has `event` handlers.
|
||
*
|
||
* @param {String} event
|
||
* @return {Boolean}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.hasListeners = function(event){
|
||
return !! this.listeners(event).length;
|
||
};
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],144:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/socket.io-parser/binary.js", module);
|
||
(function(){
|
||
(function (global){
|
||
/*global Blob,File*/
|
||
|
||
/**
|
||
* Module requirements
|
||
*/
|
||
|
||
var isArray = require('isarray');
|
||
var isBuf = require('./is-buffer');
|
||
|
||
/**
|
||
* Replaces every Buffer | ArrayBuffer in packet with a numbered placeholder.
|
||
* Anything with blobs or files should be fed through removeBlobs before coming
|
||
* here.
|
||
*
|
||
* @param {Object} packet - socket.io event packet
|
||
* @return {Object} with deconstructed packet and list of buffers
|
||
* @api public
|
||
*/
|
||
|
||
exports.deconstructPacket = function(packet){
|
||
var buffers = [];
|
||
var packetData = packet.data;
|
||
|
||
function _deconstructPacket(data) {
|
||
if (!data) return data;
|
||
|
||
if (isBuf(data)) {
|
||
var placeholder = { _placeholder: true, num: buffers.length };
|
||
buffers.push(data);
|
||
return placeholder;
|
||
} else if (isArray(data)) {
|
||
var newData = new Array(data.length);
|
||
for (var i = 0; i < data.length; i++) {
|
||
newData[i] = _deconstructPacket(data[i]);
|
||
}
|
||
return newData;
|
||
} else if ('object' == typeof data && !(data instanceof Date)) {
|
||
var newData = {};
|
||
for (var key in data) {
|
||
newData[key] = _deconstructPacket(data[key]);
|
||
}
|
||
return newData;
|
||
}
|
||
return data;
|
||
}
|
||
|
||
var pack = packet;
|
||
pack.data = _deconstructPacket(packetData);
|
||
pack.attachments = buffers.length; // number of binary 'attachments'
|
||
return {packet: pack, buffers: buffers};
|
||
};
|
||
|
||
/**
|
||
* Reconstructs a binary packet from its placeholder packet and buffers
|
||
*
|
||
* @param {Object} packet - event packet with placeholders
|
||
* @param {Array} buffers - binary buffers to put in placeholder positions
|
||
* @return {Object} reconstructed packet
|
||
* @api public
|
||
*/
|
||
|
||
exports.reconstructPacket = function(packet, buffers) {
|
||
var curPlaceHolder = 0;
|
||
|
||
function _reconstructPacket(data) {
|
||
if (data && data._placeholder) {
|
||
var buf = buffers[data.num]; // appropriate buffer (should be natural order anyway)
|
||
return buf;
|
||
} else if (isArray(data)) {
|
||
for (var i = 0; i < data.length; i++) {
|
||
data[i] = _reconstructPacket(data[i]);
|
||
}
|
||
return data;
|
||
} else if (data && 'object' == typeof data) {
|
||
for (var key in data) {
|
||
data[key] = _reconstructPacket(data[key]);
|
||
}
|
||
return data;
|
||
}
|
||
return data;
|
||
}
|
||
|
||
packet.data = _reconstructPacket(packet.data);
|
||
packet.attachments = undefined; // no longer useful
|
||
return packet;
|
||
};
|
||
|
||
/**
|
||
* Asynchronously removes Blobs or Files from data via
|
||
* FileReader's readAsArrayBuffer method. Used before encoding
|
||
* data as msgpack. Calls callback with the blobless data.
|
||
*
|
||
* @param {Object} data
|
||
* @param {Function} callback
|
||
* @api private
|
||
*/
|
||
|
||
exports.removeBlobs = function(data, callback) {
|
||
function _removeBlobs(obj, curKey, containingObject) {
|
||
if (!obj) return obj;
|
||
|
||
// convert any blob
|
||
if ((global.Blob && obj instanceof Blob) ||
|
||
(global.File && obj instanceof File)) {
|
||
pendingBlobs++;
|
||
|
||
// async filereader
|
||
var fileReader = new FileReader();
|
||
fileReader.onload = function() { // this.result == arraybuffer
|
||
if (containingObject) {
|
||
containingObject[curKey] = this.result;
|
||
}
|
||
else {
|
||
bloblessData = this.result;
|
||
}
|
||
|
||
// if nothing pending its callback time
|
||
if(! --pendingBlobs) {
|
||
callback(bloblessData);
|
||
}
|
||
};
|
||
|
||
fileReader.readAsArrayBuffer(obj); // blob -> arraybuffer
|
||
} else if (isArray(obj)) { // handle array
|
||
for (var i = 0; i < obj.length; i++) {
|
||
_removeBlobs(obj[i], i, obj);
|
||
}
|
||
} else if (obj && 'object' == typeof obj && !isBuf(obj)) { // and object
|
||
for (var key in obj) {
|
||
_removeBlobs(obj[key], key, obj);
|
||
}
|
||
}
|
||
}
|
||
|
||
var pendingBlobs = 0;
|
||
var bloblessData = data;
|
||
_removeBlobs(bloblessData);
|
||
if (!pendingBlobs) {
|
||
callback(bloblessData);
|
||
}
|
||
};
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./is-buffer":146,"isarray":64}],145:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/socket.io-parser/index.js", module);
|
||
(function(){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var debug = require('debug')('socket.io-parser');
|
||
var json = require('json3');
|
||
var isArray = require('isarray');
|
||
var Emitter = require('component-emitter');
|
||
var binary = require('./binary');
|
||
var isBuf = require('./is-buffer');
|
||
|
||
/**
|
||
* Protocol version.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.protocol = 4;
|
||
|
||
/**
|
||
* Packet types.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.types = [
|
||
'CONNECT',
|
||
'DISCONNECT',
|
||
'EVENT',
|
||
'ACK',
|
||
'ERROR',
|
||
'BINARY_EVENT',
|
||
'BINARY_ACK'
|
||
];
|
||
|
||
/**
|
||
* Packet type `connect`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.CONNECT = 0;
|
||
|
||
/**
|
||
* Packet type `disconnect`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.DISCONNECT = 1;
|
||
|
||
/**
|
||
* Packet type `event`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.EVENT = 2;
|
||
|
||
/**
|
||
* Packet type `ack`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.ACK = 3;
|
||
|
||
/**
|
||
* Packet type `error`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.ERROR = 4;
|
||
|
||
/**
|
||
* Packet type 'binary event'
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.BINARY_EVENT = 5;
|
||
|
||
/**
|
||
* Packet type `binary ack`. For acks with binary arguments.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.BINARY_ACK = 6;
|
||
|
||
/**
|
||
* Encoder constructor.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.Encoder = Encoder;
|
||
|
||
/**
|
||
* Decoder constructor.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.Decoder = Decoder;
|
||
|
||
/**
|
||
* A socket.io Encoder instance
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
function Encoder() {}
|
||
|
||
/**
|
||
* Encode a packet as a single string if non-binary, or as a
|
||
* buffer sequence, depending on packet type.
|
||
*
|
||
* @param {Object} obj - packet object
|
||
* @param {Function} callback - function to handle encodings (likely engine.write)
|
||
* @return Calls callback with Array of encodings
|
||
* @api public
|
||
*/
|
||
|
||
Encoder.prototype.encode = function(obj, callback){
|
||
debug('encoding packet %j', obj);
|
||
|
||
if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {
|
||
encodeAsBinary(obj, callback);
|
||
}
|
||
else {
|
||
var encoding = encodeAsString(obj);
|
||
callback([encoding]);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Encode packet as string.
|
||
*
|
||
* @param {Object} packet
|
||
* @return {String} encoded
|
||
* @api private
|
||
*/
|
||
|
||
function encodeAsString(obj) {
|
||
var str = '';
|
||
var nsp = false;
|
||
|
||
// first is type
|
||
str += obj.type;
|
||
|
||
// attachments if we have them
|
||
if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {
|
||
str += obj.attachments;
|
||
str += '-';
|
||
}
|
||
|
||
// if we have a namespace other than `/`
|
||
// we append it followed by a comma `,`
|
||
if (obj.nsp && '/' != obj.nsp) {
|
||
nsp = true;
|
||
str += obj.nsp;
|
||
}
|
||
|
||
// immediately followed by the id
|
||
if (null != obj.id) {
|
||
if (nsp) {
|
||
str += ',';
|
||
nsp = false;
|
||
}
|
||
str += obj.id;
|
||
}
|
||
|
||
// json data
|
||
if (null != obj.data) {
|
||
if (nsp) str += ',';
|
||
str += json.stringify(obj.data);
|
||
}
|
||
|
||
debug('encoded %j as %s', obj, str);
|
||
return str;
|
||
}
|
||
|
||
/**
|
||
* Encode packet as 'buffer sequence' by removing blobs, and
|
||
* deconstructing packet into object with placeholders and
|
||
* a list of buffers.
|
||
*
|
||
* @param {Object} packet
|
||
* @return {Buffer} encoded
|
||
* @api private
|
||
*/
|
||
|
||
function encodeAsBinary(obj, callback) {
|
||
|
||
function writeEncoding(bloblessData) {
|
||
var deconstruction = binary.deconstructPacket(bloblessData);
|
||
var pack = encodeAsString(deconstruction.packet);
|
||
var buffers = deconstruction.buffers;
|
||
|
||
buffers.unshift(pack); // add packet info to beginning of data list
|
||
callback(buffers); // write all the buffers
|
||
}
|
||
|
||
binary.removeBlobs(obj, writeEncoding);
|
||
}
|
||
|
||
/**
|
||
* A socket.io Decoder instance
|
||
*
|
||
* @return {Object} decoder
|
||
* @api public
|
||
*/
|
||
|
||
function Decoder() {
|
||
this.reconstructor = null;
|
||
}
|
||
|
||
/**
|
||
* Mix in `Emitter` with Decoder.
|
||
*/
|
||
|
||
Emitter(Decoder.prototype);
|
||
|
||
/**
|
||
* Decodes an ecoded packet string into packet JSON.
|
||
*
|
||
* @param {String} obj - encoded packet
|
||
* @return {Object} packet
|
||
* @api public
|
||
*/
|
||
|
||
Decoder.prototype.add = function(obj) {
|
||
var packet;
|
||
if ('string' == typeof obj) {
|
||
packet = decodeString(obj);
|
||
if (exports.BINARY_EVENT == packet.type || exports.BINARY_ACK == packet.type) { // binary packet's json
|
||
this.reconstructor = new BinaryReconstructor(packet);
|
||
|
||
// no attachments, labeled binary but no binary data to follow
|
||
if (this.reconstructor.reconPack.attachments === 0) {
|
||
this.emit('decoded', packet);
|
||
}
|
||
} else { // non-binary full packet
|
||
this.emit('decoded', packet);
|
||
}
|
||
}
|
||
else if (isBuf(obj) || obj.base64) { // raw binary data
|
||
if (!this.reconstructor) {
|
||
throw new Error('got binary data when not reconstructing a packet');
|
||
} else {
|
||
packet = this.reconstructor.takeBinaryData(obj);
|
||
if (packet) { // received final buffer
|
||
this.reconstructor = null;
|
||
this.emit('decoded', packet);
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
throw new Error('Unknown type: ' + obj);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Decode a packet String (JSON data)
|
||
*
|
||
* @param {String} str
|
||
* @return {Object} packet
|
||
* @api private
|
||
*/
|
||
|
||
function decodeString(str) {
|
||
var p = {};
|
||
var i = 0;
|
||
|
||
// look up type
|
||
p.type = Number(str.charAt(0));
|
||
if (null == exports.types[p.type]) return error();
|
||
|
||
// look up attachments if type binary
|
||
if (exports.BINARY_EVENT == p.type || exports.BINARY_ACK == p.type) {
|
||
var buf = '';
|
||
while (str.charAt(++i) != '-') {
|
||
buf += str.charAt(i);
|
||
if (i == str.length) break;
|
||
}
|
||
if (buf != Number(buf) || str.charAt(i) != '-') {
|
||
throw new Error('Illegal attachments');
|
||
}
|
||
p.attachments = Number(buf);
|
||
}
|
||
|
||
// look up namespace (if any)
|
||
if ('/' == str.charAt(i + 1)) {
|
||
p.nsp = '';
|
||
while (++i) {
|
||
var c = str.charAt(i);
|
||
if (',' == c) break;
|
||
p.nsp += c;
|
||
if (i == str.length) break;
|
||
}
|
||
} else {
|
||
p.nsp = '/';
|
||
}
|
||
|
||
// look up id
|
||
var next = str.charAt(i + 1);
|
||
if ('' !== next && Number(next) == next) {
|
||
p.id = '';
|
||
while (++i) {
|
||
var c = str.charAt(i);
|
||
if (null == c || Number(c) != c) {
|
||
--i;
|
||
break;
|
||
}
|
||
p.id += str.charAt(i);
|
||
if (i == str.length) break;
|
||
}
|
||
p.id = Number(p.id);
|
||
}
|
||
|
||
// look up json data
|
||
if (str.charAt(++i)) {
|
||
try {
|
||
p.data = json.parse(str.substr(i));
|
||
} catch(e){
|
||
return error();
|
||
}
|
||
}
|
||
|
||
debug('decoded %s as %j', str, p);
|
||
return p;
|
||
}
|
||
|
||
/**
|
||
* Deallocates a parser's resources
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Decoder.prototype.destroy = function() {
|
||
if (this.reconstructor) {
|
||
this.reconstructor.finishedReconstruction();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* A manager of a binary event's 'buffer sequence'. Should
|
||
* be constructed whenever a packet of type BINARY_EVENT is
|
||
* decoded.
|
||
*
|
||
* @param {Object} packet
|
||
* @return {BinaryReconstructor} initialized reconstructor
|
||
* @api private
|
||
*/
|
||
|
||
function BinaryReconstructor(packet) {
|
||
this.reconPack = packet;
|
||
this.buffers = [];
|
||
}
|
||
|
||
/**
|
||
* Method to be called when binary data received from connection
|
||
* after a BINARY_EVENT packet.
|
||
*
|
||
* @param {Buffer | ArrayBuffer} binData - the raw binary data received
|
||
* @return {null | Object} returns null if more binary data is expected or
|
||
* a reconstructed packet object if all buffers have been received.
|
||
* @api private
|
||
*/
|
||
|
||
BinaryReconstructor.prototype.takeBinaryData = function(binData) {
|
||
this.buffers.push(binData);
|
||
if (this.buffers.length == this.reconPack.attachments) { // done with buffer list
|
||
var packet = binary.reconstructPacket(this.reconPack, this.buffers);
|
||
this.finishedReconstruction();
|
||
return packet;
|
||
}
|
||
return null;
|
||
};
|
||
|
||
/**
|
||
* Cleans up binary packet reconstruction variables.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
BinaryReconstructor.prototype.finishedReconstruction = function() {
|
||
this.reconPack = null;
|
||
this.buffers = [];
|
||
};
|
||
|
||
function error(data){
|
||
return {
|
||
type: exports.ERROR,
|
||
data: 'parser error'
|
||
};
|
||
}
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./binary":144,"./is-buffer":146,"component-emitter":14,"debug":46,"isarray":64,"json3":147}],146:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/socket.io-parser/is-buffer.js", module);
|
||
(function(){
|
||
(function (global){
|
||
|
||
module.exports = isBuf;
|
||
|
||
/**
|
||
* Returns true if obj is a buffer or an arraybuffer.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
function isBuf(obj) {
|
||
return (global.Buffer && global.Buffer.isBuffer(obj)) ||
|
||
(global.ArrayBuffer && obj instanceof ArrayBuffer);
|
||
}
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],147:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/socket.io-parser/node_modules/json3/lib/json3.js", module);
|
||
(function(){
|
||
(function (global){
|
||
/*! JSON v3.3.2 | http://bestiejs.github.io/json3 | Copyright 2012-2014, Kit Cambridge | http://kit.mit-license.org */
|
||
;(function () {
|
||
// Detect the `define` function exposed by asynchronous module loaders. The
|
||
// strict `define` check is necessary for compatibility with `r.js`.
|
||
var isLoader = typeof define === "function" && define.amd;
|
||
|
||
// A set of types used to distinguish objects from primitives.
|
||
var objectTypes = {
|
||
"function": true,
|
||
"object": true
|
||
};
|
||
|
||
// Detect the `exports` object exposed by CommonJS implementations.
|
||
var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;
|
||
|
||
// Use the `global` object exposed by Node (including Browserify via
|
||
// `insert-module-globals`), Narwhal, and Ringo as the default context,
|
||
// and the `window` object in browsers. Rhino exports a `global` function
|
||
// instead.
|
||
var root = objectTypes[typeof window] && window || this,
|
||
freeGlobal = freeExports && objectTypes[typeof module] && module && !module.nodeType && typeof global == "object" && global;
|
||
|
||
if (freeGlobal && (freeGlobal["global"] === freeGlobal || freeGlobal["window"] === freeGlobal || freeGlobal["self"] === freeGlobal)) {
|
||
root = freeGlobal;
|
||
}
|
||
|
||
// Public: Initializes JSON 3 using the given `context` object, attaching the
|
||
// `stringify` and `parse` functions to the specified `exports` object.
|
||
function runInContext(context, exports) {
|
||
context || (context = root["Object"]());
|
||
exports || (exports = root["Object"]());
|
||
|
||
// Native constructor aliases.
|
||
var Number = context["Number"] || root["Number"],
|
||
String = context["String"] || root["String"],
|
||
Object = context["Object"] || root["Object"],
|
||
Date = context["Date"] || root["Date"],
|
||
SyntaxError = context["SyntaxError"] || root["SyntaxError"],
|
||
TypeError = context["TypeError"] || root["TypeError"],
|
||
Math = context["Math"] || root["Math"],
|
||
nativeJSON = context["JSON"] || root["JSON"];
|
||
|
||
// Delegate to the native `stringify` and `parse` implementations.
|
||
if (typeof nativeJSON == "object" && nativeJSON) {
|
||
exports.stringify = nativeJSON.stringify;
|
||
exports.parse = nativeJSON.parse;
|
||
}
|
||
|
||
// Convenience aliases.
|
||
var objectProto = Object.prototype,
|
||
getClass = objectProto.toString,
|
||
isProperty, forEach, undef;
|
||
|
||
// Test the `Date#getUTC*` methods. Based on work by @Yaffle.
|
||
var isExtended = new Date(-3509827334573292);
|
||
try {
|
||
// The `getUTCFullYear`, `Month`, and `Date` methods return nonsensical
|
||
// results for certain dates in Opera >= 10.53.
|
||
isExtended = isExtended.getUTCFullYear() == -109252 && isExtended.getUTCMonth() === 0 && isExtended.getUTCDate() === 1 &&
|
||
// Safari < 2.0.2 stores the internal millisecond time value correctly,
|
||
// but clips the values returned by the date methods to the range of
|
||
// signed 32-bit integers ([-2 ** 31, 2 ** 31 - 1]).
|
||
isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708;
|
||
} catch (exception) {}
|
||
|
||
// Internal: Determines whether the native `JSON.stringify` and `parse`
|
||
// implementations are spec-compliant. Based on work by Ken Snyder.
|
||
function has(name) {
|
||
if (has[name] !== undef) {
|
||
// Return cached feature test result.
|
||
return has[name];
|
||
}
|
||
var isSupported;
|
||
if (name == "bug-string-char-index") {
|
||
// IE <= 7 doesn't support accessing string characters using square
|
||
// bracket notation. IE 8 only supports this for primitives.
|
||
isSupported = "a"[0] != "a";
|
||
} else if (name == "json") {
|
||
// Indicates whether both `JSON.stringify` and `JSON.parse` are
|
||
// supported.
|
||
isSupported = has("json-stringify") && has("json-parse");
|
||
} else {
|
||
var value, serialized = '{"a":[1,true,false,null,"\\u0000\\b\\n\\f\\r\\t"]}';
|
||
// Test `JSON.stringify`.
|
||
if (name == "json-stringify") {
|
||
var stringify = exports.stringify, stringifySupported = typeof stringify == "function" && isExtended;
|
||
if (stringifySupported) {
|
||
// A test function object with a custom `toJSON` method.
|
||
(value = function () {
|
||
return 1;
|
||
}).toJSON = value;
|
||
try {
|
||
stringifySupported =
|
||
// Firefox 3.1b1 and b2 serialize string, number, and boolean
|
||
// primitives as object literals.
|
||
stringify(0) === "0" &&
|
||
// FF 3.1b1, b2, and JSON 2 serialize wrapped primitives as object
|
||
// literals.
|
||
stringify(new Number()) === "0" &&
|
||
stringify(new String()) == '""' &&
|
||
// FF 3.1b1, 2 throw an error if the value is `null`, `undefined`, or
|
||
// does not define a canonical JSON representation (this applies to
|
||
// objects with `toJSON` properties as well, *unless* they are nested
|
||
// within an object or array).
|
||
stringify(getClass) === undef &&
|
||
// IE 8 serializes `undefined` as `"undefined"`. Safari <= 5.1.7 and
|
||
// FF 3.1b3 pass this test.
|
||
stringify(undef) === undef &&
|
||
// Safari <= 5.1.7 and FF 3.1b3 throw `Error`s and `TypeError`s,
|
||
// respectively, if the value is omitted entirely.
|
||
stringify() === undef &&
|
||
// FF 3.1b1, 2 throw an error if the given value is not a number,
|
||
// string, array, object, Boolean, or `null` literal. This applies to
|
||
// objects with custom `toJSON` methods as well, unless they are nested
|
||
// inside object or array literals. YUI 3.0.0b1 ignores custom `toJSON`
|
||
// methods entirely.
|
||
stringify(value) === "1" &&
|
||
stringify([value]) == "[1]" &&
|
||
// Prototype <= 1.6.1 serializes `[undefined]` as `"[]"` instead of
|
||
// `"[null]"`.
|
||
stringify([undef]) == "[null]" &&
|
||
// YUI 3.0.0b1 fails to serialize `null` literals.
|
||
stringify(null) == "null" &&
|
||
// FF 3.1b1, 2 halts serialization if an array contains a function:
|
||
// `[1, true, getClass, 1]` serializes as "[1,true,],". FF 3.1b3
|
||
// elides non-JSON values from objects and arrays, unless they
|
||
// define custom `toJSON` methods.
|
||
stringify([undef, getClass, null]) == "[null,null,null]" &&
|
||
// Simple serialization test. FF 3.1b1 uses Unicode escape sequences
|
||
// where character escape codes are expected (e.g., `\b` => `\u0008`).
|
||
stringify({ "a": [value, true, false, null, "\x00\b\n\f\r\t"] }) == serialized &&
|
||
// FF 3.1b1 and b2 ignore the `filter` and `width` arguments.
|
||
stringify(null, value) === "1" &&
|
||
stringify([1, 2], null, 1) == "[\n 1,\n 2\n]" &&
|
||
// JSON 2, Prototype <= 1.7, and older WebKit builds incorrectly
|
||
// serialize extended years.
|
||
stringify(new Date(-8.64e15)) == '"-271821-04-20T00:00:00.000Z"' &&
|
||
// The milliseconds are optional in ES 5, but required in 5.1.
|
||
stringify(new Date(8.64e15)) == '"+275760-09-13T00:00:00.000Z"' &&
|
||
// Firefox <= 11.0 incorrectly serializes years prior to 0 as negative
|
||
// four-digit years instead of six-digit years. Credits: @Yaffle.
|
||
stringify(new Date(-621987552e5)) == '"-000001-01-01T00:00:00.000Z"' &&
|
||
// Safari <= 5.1.5 and Opera >= 10.53 incorrectly serialize millisecond
|
||
// values less than 1000. Credits: @Yaffle.
|
||
stringify(new Date(-1)) == '"1969-12-31T23:59:59.999Z"';
|
||
} catch (exception) {
|
||
stringifySupported = false;
|
||
}
|
||
}
|
||
isSupported = stringifySupported;
|
||
}
|
||
// Test `JSON.parse`.
|
||
if (name == "json-parse") {
|
||
var parse = exports.parse;
|
||
if (typeof parse == "function") {
|
||
try {
|
||
// FF 3.1b1, b2 will throw an exception if a bare literal is provided.
|
||
// Conforming implementations should also coerce the initial argument to
|
||
// a string prior to parsing.
|
||
if (parse("0") === 0 && !parse(false)) {
|
||
// Simple parsing test.
|
||
value = parse(serialized);
|
||
var parseSupported = value["a"].length == 5 && value["a"][0] === 1;
|
||
if (parseSupported) {
|
||
try {
|
||
// Safari <= 5.1.2 and FF 3.1b1 allow unescaped tabs in strings.
|
||
parseSupported = !parse('"\t"');
|
||
} catch (exception) {}
|
||
if (parseSupported) {
|
||
try {
|
||
// FF 4.0 and 4.0.1 allow leading `+` signs and leading
|
||
// decimal points. FF 4.0, 4.0.1, and IE 9-10 also allow
|
||
// certain octal literals.
|
||
parseSupported = parse("01") !== 1;
|
||
} catch (exception) {}
|
||
}
|
||
if (parseSupported) {
|
||
try {
|
||
// FF 4.0, 4.0.1, and Rhino 1.7R3-R4 allow trailing decimal
|
||
// points. These environments, along with FF 3.1b1 and 2,
|
||
// also allow trailing commas in JSON objects and arrays.
|
||
parseSupported = parse("1.") !== 1;
|
||
} catch (exception) {}
|
||
}
|
||
}
|
||
}
|
||
} catch (exception) {
|
||
parseSupported = false;
|
||
}
|
||
}
|
||
isSupported = parseSupported;
|
||
}
|
||
}
|
||
return has[name] = !!isSupported;
|
||
}
|
||
|
||
if (!has("json")) {
|
||
// Common `[[Class]]` name aliases.
|
||
var functionClass = "[object Function]",
|
||
dateClass = "[object Date]",
|
||
numberClass = "[object Number]",
|
||
stringClass = "[object String]",
|
||
arrayClass = "[object Array]",
|
||
booleanClass = "[object Boolean]";
|
||
|
||
// Detect incomplete support for accessing string characters by index.
|
||
var charIndexBuggy = has("bug-string-char-index");
|
||
|
||
// Define additional utility methods if the `Date` methods are buggy.
|
||
if (!isExtended) {
|
||
var floor = Math.floor;
|
||
// A mapping between the months of the year and the number of days between
|
||
// January 1st and the first of the respective month.
|
||
var Months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
|
||
// Internal: Calculates the number of days between the Unix epoch and the
|
||
// first day of the given month.
|
||
var getDay = function (year, month) {
|
||
return Months[month] + 365 * (year - 1970) + floor((year - 1969 + (month = +(month > 1))) / 4) - floor((year - 1901 + month) / 100) + floor((year - 1601 + month) / 400);
|
||
};
|
||
}
|
||
|
||
// Internal: Determines if a property is a direct property of the given
|
||
// object. Delegates to the native `Object#hasOwnProperty` method.
|
||
if (!(isProperty = objectProto.hasOwnProperty)) {
|
||
isProperty = function (property) {
|
||
var members = {}, constructor;
|
||
if ((members.__proto__ = null, members.__proto__ = {
|
||
// The *proto* property cannot be set multiple times in recent
|
||
// versions of Firefox and SeaMonkey.
|
||
"toString": 1
|
||
}, members).toString != getClass) {
|
||
// Safari <= 2.0.3 doesn't implement `Object#hasOwnProperty`, but
|
||
// supports the mutable *proto* property.
|
||
isProperty = function (property) {
|
||
// Capture and break the object's prototype chain (see section 8.6.2
|
||
// of the ES 5.1 spec). The parenthesized expression prevents an
|
||
// unsafe transformation by the Closure Compiler.
|
||
var original = this.__proto__, result = property in (this.__proto__ = null, this);
|
||
// Restore the original prototype chain.
|
||
this.__proto__ = original;
|
||
return result;
|
||
};
|
||
} else {
|
||
// Capture a reference to the top-level `Object` constructor.
|
||
constructor = members.constructor;
|
||
// Use the `constructor` property to simulate `Object#hasOwnProperty` in
|
||
// other environments.
|
||
isProperty = function (property) {
|
||
var parent = (this.constructor || constructor).prototype;
|
||
return property in this && !(property in parent && this[property] === parent[property]);
|
||
};
|
||
}
|
||
members = null;
|
||
return isProperty.call(this, property);
|
||
};
|
||
}
|
||
|
||
// Internal: Normalizes the `for...in` iteration algorithm across
|
||
// environments. Each enumerated key is yielded to a `callback` function.
|
||
forEach = function (object, callback) {
|
||
var size = 0, Properties, members, property;
|
||
|
||
// Tests for bugs in the current environment's `for...in` algorithm. The
|
||
// `valueOf` property inherits the non-enumerable flag from
|
||
// `Object.prototype` in older versions of IE, Netscape, and Mozilla.
|
||
(Properties = function () {
|
||
this.valueOf = 0;
|
||
}).prototype.valueOf = 0;
|
||
|
||
// Iterate over a new instance of the `Properties` class.
|
||
members = new Properties();
|
||
for (property in members) {
|
||
// Ignore all properties inherited from `Object.prototype`.
|
||
if (isProperty.call(members, property)) {
|
||
size++;
|
||
}
|
||
}
|
||
Properties = members = null;
|
||
|
||
// Normalize the iteration algorithm.
|
||
if (!size) {
|
||
// A list of non-enumerable properties inherited from `Object.prototype`.
|
||
members = ["valueOf", "toString", "toLocaleString", "propertyIsEnumerable", "isPrototypeOf", "hasOwnProperty", "constructor"];
|
||
// IE <= 8, Mozilla 1.0, and Netscape 6.2 ignore shadowed non-enumerable
|
||
// properties.
|
||
forEach = function (object, callback) {
|
||
var isFunction = getClass.call(object) == functionClass, property, length;
|
||
var hasProperty = !isFunction && typeof object.constructor != "function" && objectTypes[typeof object.hasOwnProperty] && object.hasOwnProperty || isProperty;
|
||
for (property in object) {
|
||
// Gecko <= 1.0 enumerates the `prototype` property of functions under
|
||
// certain conditions; IE does not.
|
||
if (!(isFunction && property == "prototype") && hasProperty.call(object, property)) {
|
||
callback(property);
|
||
}
|
||
}
|
||
// Manually invoke the callback for each non-enumerable property.
|
||
for (length = members.length; property = members[--length]; hasProperty.call(object, property) && callback(property));
|
||
};
|
||
} else if (size == 2) {
|
||
// Safari <= 2.0.4 enumerates shadowed properties twice.
|
||
forEach = function (object, callback) {
|
||
// Create a set of iterated properties.
|
||
var members = {}, isFunction = getClass.call(object) == functionClass, property;
|
||
for (property in object) {
|
||
// Store each property name to prevent double enumeration. The
|
||
// `prototype` property of functions is not enumerated due to cross-
|
||
// environment inconsistencies.
|
||
if (!(isFunction && property == "prototype") && !isProperty.call(members, property) && (members[property] = 1) && isProperty.call(object, property)) {
|
||
callback(property);
|
||
}
|
||
}
|
||
};
|
||
} else {
|
||
// No bugs detected; use the standard `for...in` algorithm.
|
||
forEach = function (object, callback) {
|
||
var isFunction = getClass.call(object) == functionClass, property, isConstructor;
|
||
for (property in object) {
|
||
if (!(isFunction && property == "prototype") && isProperty.call(object, property) && !(isConstructor = property === "constructor")) {
|
||
callback(property);
|
||
}
|
||
}
|
||
// Manually invoke the callback for the `constructor` property due to
|
||
// cross-environment inconsistencies.
|
||
if (isConstructor || isProperty.call(object, (property = "constructor"))) {
|
||
callback(property);
|
||
}
|
||
};
|
||
}
|
||
return forEach(object, callback);
|
||
};
|
||
|
||
// Public: Serializes a JavaScript `value` as a JSON string. The optional
|
||
// `filter` argument may specify either a function that alters how object and
|
||
// array members are serialized, or an array of strings and numbers that
|
||
// indicates which properties should be serialized. The optional `width`
|
||
// argument may be either a string or number that specifies the indentation
|
||
// level of the output.
|
||
if (!has("json-stringify")) {
|
||
// Internal: A map of control characters and their escaped equivalents.
|
||
var Escapes = {
|
||
92: "\\\\",
|
||
34: '\\"',
|
||
8: "\\b",
|
||
12: "\\f",
|
||
10: "\\n",
|
||
13: "\\r",
|
||
9: "\\t"
|
||
};
|
||
|
||
// Internal: Converts `value` into a zero-padded string such that its
|
||
// length is at least equal to `width`. The `width` must be <= 6.
|
||
var leadingZeroes = "000000";
|
||
var toPaddedString = function (width, value) {
|
||
// The `|| 0` expression is necessary to work around a bug in
|
||
// Opera <= 7.54u2 where `0 == -0`, but `String(-0) !== "0"`.
|
||
return (leadingZeroes + (value || 0)).slice(-width);
|
||
};
|
||
|
||
// Internal: Double-quotes a string `value`, replacing all ASCII control
|
||
// characters (characters with code unit values between 0 and 31) with
|
||
// their escaped equivalents. This is an implementation of the
|
||
// `Quote(value)` operation defined in ES 5.1 section 15.12.3.
|
||
var unicodePrefix = "\\u00";
|
||
var quote = function (value) {
|
||
var result = '"', index = 0, length = value.length, useCharIndex = !charIndexBuggy || length > 10;
|
||
var symbols = useCharIndex && (charIndexBuggy ? value.split("") : value);
|
||
for (; index < length; index++) {
|
||
var charCode = value.charCodeAt(index);
|
||
// If the character is a control character, append its Unicode or
|
||
// shorthand escape sequence; otherwise, append the character as-is.
|
||
switch (charCode) {
|
||
case 8: case 9: case 10: case 12: case 13: case 34: case 92:
|
||
result += Escapes[charCode];
|
||
break;
|
||
default:
|
||
if (charCode < 32) {
|
||
result += unicodePrefix + toPaddedString(2, charCode.toString(16));
|
||
break;
|
||
}
|
||
result += useCharIndex ? symbols[index] : value.charAt(index);
|
||
}
|
||
}
|
||
return result + '"';
|
||
};
|
||
|
||
// Internal: Recursively serializes an object. Implements the
|
||
// `Str(key, holder)`, `JO(value)`, and `JA(value)` operations.
|
||
var serialize = function (property, object, callback, properties, whitespace, indentation, stack) {
|
||
var value, className, year, month, date, time, hours, minutes, seconds, milliseconds, results, element, index, length, prefix, result;
|
||
try {
|
||
// Necessary for host object support.
|
||
value = object[property];
|
||
} catch (exception) {}
|
||
if (typeof value == "object" && value) {
|
||
className = getClass.call(value);
|
||
if (className == dateClass && !isProperty.call(value, "toJSON")) {
|
||
if (value > -1 / 0 && value < 1 / 0) {
|
||
// Dates are serialized according to the `Date#toJSON` method
|
||
// specified in ES 5.1 section 15.9.5.44. See section 15.9.1.15
|
||
// for the ISO 8601 date time string format.
|
||
if (getDay) {
|
||
// Manually compute the year, month, date, hours, minutes,
|
||
// seconds, and milliseconds if the `getUTC*` methods are
|
||
// buggy. Adapted from @Yaffle's `date-shim` project.
|
||
date = floor(value / 864e5);
|
||
for (year = floor(date / 365.2425) + 1970 - 1; getDay(year + 1, 0) <= date; year++);
|
||
for (month = floor((date - getDay(year, 0)) / 30.42); getDay(year, month + 1) <= date; month++);
|
||
date = 1 + date - getDay(year, month);
|
||
// The `time` value specifies the time within the day (see ES
|
||
// 5.1 section 15.9.1.2). The formula `(A % B + B) % B` is used
|
||
// to compute `A modulo B`, as the `%` operator does not
|
||
// correspond to the `modulo` operation for negative numbers.
|
||
time = (value % 864e5 + 864e5) % 864e5;
|
||
// The hours, minutes, seconds, and milliseconds are obtained by
|
||
// decomposing the time within the day. See section 15.9.1.10.
|
||
hours = floor(time / 36e5) % 24;
|
||
minutes = floor(time / 6e4) % 60;
|
||
seconds = floor(time / 1e3) % 60;
|
||
milliseconds = time % 1e3;
|
||
} else {
|
||
year = value.getUTCFullYear();
|
||
month = value.getUTCMonth();
|
||
date = value.getUTCDate();
|
||
hours = value.getUTCHours();
|
||
minutes = value.getUTCMinutes();
|
||
seconds = value.getUTCSeconds();
|
||
milliseconds = value.getUTCMilliseconds();
|
||
}
|
||
// Serialize extended years correctly.
|
||
value = (year <= 0 || year >= 1e4 ? (year < 0 ? "-" : "+") + toPaddedString(6, year < 0 ? -year : year) : toPaddedString(4, year)) +
|
||
"-" + toPaddedString(2, month + 1) + "-" + toPaddedString(2, date) +
|
||
// Months, dates, hours, minutes, and seconds should have two
|
||
// digits; milliseconds should have three.
|
||
"T" + toPaddedString(2, hours) + ":" + toPaddedString(2, minutes) + ":" + toPaddedString(2, seconds) +
|
||
// Milliseconds are optional in ES 5.0, but required in 5.1.
|
||
"." + toPaddedString(3, milliseconds) + "Z";
|
||
} else {
|
||
value = null;
|
||
}
|
||
} else if (typeof value.toJSON == "function" && ((className != numberClass && className != stringClass && className != arrayClass) || isProperty.call(value, "toJSON"))) {
|
||
// Prototype <= 1.6.1 adds non-standard `toJSON` methods to the
|
||
// `Number`, `String`, `Date`, and `Array` prototypes. JSON 3
|
||
// ignores all `toJSON` methods on these objects unless they are
|
||
// defined directly on an instance.
|
||
value = value.toJSON(property);
|
||
}
|
||
}
|
||
if (callback) {
|
||
// If a replacement function was provided, call it to obtain the value
|
||
// for serialization.
|
||
value = callback.call(object, property, value);
|
||
}
|
||
if (value === null) {
|
||
return "null";
|
||
}
|
||
className = getClass.call(value);
|
||
if (className == booleanClass) {
|
||
// Booleans are represented literally.
|
||
return "" + value;
|
||
} else if (className == numberClass) {
|
||
// JSON numbers must be finite. `Infinity` and `NaN` are serialized as
|
||
// `"null"`.
|
||
return value > -1 / 0 && value < 1 / 0 ? "" + value : "null";
|
||
} else if (className == stringClass) {
|
||
// Strings are double-quoted and escaped.
|
||
return quote("" + value);
|
||
}
|
||
// Recursively serialize objects and arrays.
|
||
if (typeof value == "object") {
|
||
// Check for cyclic structures. This is a linear search; performance
|
||
// is inversely proportional to the number of unique nested objects.
|
||
for (length = stack.length; length--;) {
|
||
if (stack[length] === value) {
|
||
// Cyclic structures cannot be serialized by `JSON.stringify`.
|
||
throw TypeError();
|
||
}
|
||
}
|
||
// Add the object to the stack of traversed objects.
|
||
stack.push(value);
|
||
results = [];
|
||
// Save the current indentation level and indent one additional level.
|
||
prefix = indentation;
|
||
indentation += whitespace;
|
||
if (className == arrayClass) {
|
||
// Recursively serialize array elements.
|
||
for (index = 0, length = value.length; index < length; index++) {
|
||
element = serialize(index, value, callback, properties, whitespace, indentation, stack);
|
||
results.push(element === undef ? "null" : element);
|
||
}
|
||
result = results.length ? (whitespace ? "[\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "]" : ("[" + results.join(",") + "]")) : "[]";
|
||
} else {
|
||
// Recursively serialize object members. Members are selected from
|
||
// either a user-specified list of property names, or the object
|
||
// itself.
|
||
forEach(properties || value, function (property) {
|
||
var element = serialize(property, value, callback, properties, whitespace, indentation, stack);
|
||
if (element !== undef) {
|
||
// According to ES 5.1 section 15.12.3: "If `gap` {whitespace}
|
||
// is not the empty string, let `member` {quote(property) + ":"}
|
||
// be the concatenation of `member` and the `space` character."
|
||
// The "`space` character" refers to the literal space
|
||
// character, not the `space` {width} argument provided to
|
||
// `JSON.stringify`.
|
||
results.push(quote(property) + ":" + (whitespace ? " " : "") + element);
|
||
}
|
||
});
|
||
result = results.length ? (whitespace ? "{\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "}" : ("{" + results.join(",") + "}")) : "{}";
|
||
}
|
||
// Remove the object from the traversed object stack.
|
||
stack.pop();
|
||
return result;
|
||
}
|
||
};
|
||
|
||
// Public: `JSON.stringify`. See ES 5.1 section 15.12.3.
|
||
exports.stringify = function (source, filter, width) {
|
||
var whitespace, callback, properties, className;
|
||
if (objectTypes[typeof filter] && filter) {
|
||
if ((className = getClass.call(filter)) == functionClass) {
|
||
callback = filter;
|
||
} else if (className == arrayClass) {
|
||
// Convert the property names array into a makeshift set.
|
||
properties = {};
|
||
for (var index = 0, length = filter.length, value; index < length; value = filter[index++], ((className = getClass.call(value)), className == stringClass || className == numberClass) && (properties[value] = 1));
|
||
}
|
||
}
|
||
if (width) {
|
||
if ((className = getClass.call(width)) == numberClass) {
|
||
// Convert the `width` to an integer and create a string containing
|
||
// `width` number of space characters.
|
||
if ((width -= width % 1) > 0) {
|
||
for (whitespace = "", width > 10 && (width = 10); whitespace.length < width; whitespace += " ");
|
||
}
|
||
} else if (className == stringClass) {
|
||
whitespace = width.length <= 10 ? width : width.slice(0, 10);
|
||
}
|
||
}
|
||
// Opera <= 7.54u2 discards the values associated with empty string keys
|
||
// (`""`) only if they are used directly within an object member list
|
||
// (e.g., `!("" in { "": 1})`).
|
||
return serialize("", (value = {}, value[""] = source, value), callback, properties, whitespace, "", []);
|
||
};
|
||
}
|
||
|
||
// Public: Parses a JSON source string.
|
||
if (!has("json-parse")) {
|
||
var fromCharCode = String.fromCharCode;
|
||
|
||
// Internal: A map of escaped control characters and their unescaped
|
||
// equivalents.
|
||
var Unescapes = {
|
||
92: "\\",
|
||
34: '"',
|
||
47: "/",
|
||
98: "\b",
|
||
116: "\t",
|
||
110: "\n",
|
||
102: "\f",
|
||
114: "\r"
|
||
};
|
||
|
||
// Internal: Stores the parser state.
|
||
var Index, Source;
|
||
|
||
// Internal: Resets the parser state and throws a `SyntaxError`.
|
||
var abort = function () {
|
||
Index = Source = null;
|
||
throw SyntaxError();
|
||
};
|
||
|
||
// Internal: Returns the next token, or `"$"` if the parser has reached
|
||
// the end of the source string. A token may be a string, number, `null`
|
||
// literal, or Boolean literal.
|
||
var lex = function () {
|
||
var source = Source, length = source.length, value, begin, position, isSigned, charCode;
|
||
while (Index < length) {
|
||
charCode = source.charCodeAt(Index);
|
||
switch (charCode) {
|
||
case 9: case 10: case 13: case 32:
|
||
// Skip whitespace tokens, including tabs, carriage returns, line
|
||
// feeds, and space characters.
|
||
Index++;
|
||
break;
|
||
case 123: case 125: case 91: case 93: case 58: case 44:
|
||
// Parse a punctuator token (`{`, `}`, `[`, `]`, `:`, or `,`) at
|
||
// the current position.
|
||
value = charIndexBuggy ? source.charAt(Index) : source[Index];
|
||
Index++;
|
||
return value;
|
||
case 34:
|
||
// `"` delimits a JSON string; advance to the next character and
|
||
// begin parsing the string. String tokens are prefixed with the
|
||
// sentinel `@` character to distinguish them from punctuators and
|
||
// end-of-string tokens.
|
||
for (value = "@", Index++; Index < length;) {
|
||
charCode = source.charCodeAt(Index);
|
||
if (charCode < 32) {
|
||
// Unescaped ASCII control characters (those with a code unit
|
||
// less than the space character) are not permitted.
|
||
abort();
|
||
} else if (charCode == 92) {
|
||
// A reverse solidus (`\`) marks the beginning of an escaped
|
||
// control character (including `"`, `\`, and `/`) or Unicode
|
||
// escape sequence.
|
||
charCode = source.charCodeAt(++Index);
|
||
switch (charCode) {
|
||
case 92: case 34: case 47: case 98: case 116: case 110: case 102: case 114:
|
||
// Revive escaped control characters.
|
||
value += Unescapes[charCode];
|
||
Index++;
|
||
break;
|
||
case 117:
|
||
// `\u` marks the beginning of a Unicode escape sequence.
|
||
// Advance to the first character and validate the
|
||
// four-digit code point.
|
||
begin = ++Index;
|
||
for (position = Index + 4; Index < position; Index++) {
|
||
charCode = source.charCodeAt(Index);
|
||
// A valid sequence comprises four hexdigits (case-
|
||
// insensitive) that form a single hexadecimal value.
|
||
if (!(charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70)) {
|
||
// Invalid Unicode escape sequence.
|
||
abort();
|
||
}
|
||
}
|
||
// Revive the escaped character.
|
||
value += fromCharCode("0x" + source.slice(begin, Index));
|
||
break;
|
||
default:
|
||
// Invalid escape sequence.
|
||
abort();
|
||
}
|
||
} else {
|
||
if (charCode == 34) {
|
||
// An unescaped double-quote character marks the end of the
|
||
// string.
|
||
break;
|
||
}
|
||
charCode = source.charCodeAt(Index);
|
||
begin = Index;
|
||
// Optimize for the common case where a string is valid.
|
||
while (charCode >= 32 && charCode != 92 && charCode != 34) {
|
||
charCode = source.charCodeAt(++Index);
|
||
}
|
||
// Append the string as-is.
|
||
value += source.slice(begin, Index);
|
||
}
|
||
}
|
||
if (source.charCodeAt(Index) == 34) {
|
||
// Advance to the next character and return the revived string.
|
||
Index++;
|
||
return value;
|
||
}
|
||
// Unterminated string.
|
||
abort();
|
||
default:
|
||
// Parse numbers and literals.
|
||
begin = Index;
|
||
// Advance past the negative sign, if one is specified.
|
||
if (charCode == 45) {
|
||
isSigned = true;
|
||
charCode = source.charCodeAt(++Index);
|
||
}
|
||
// Parse an integer or floating-point value.
|
||
if (charCode >= 48 && charCode <= 57) {
|
||
// Leading zeroes are interpreted as octal literals.
|
||
if (charCode == 48 && ((charCode = source.charCodeAt(Index + 1)), charCode >= 48 && charCode <= 57)) {
|
||
// Illegal octal literal.
|
||
abort();
|
||
}
|
||
isSigned = false;
|
||
// Parse the integer component.
|
||
for (; Index < length && ((charCode = source.charCodeAt(Index)), charCode >= 48 && charCode <= 57); Index++);
|
||
// Floats cannot contain a leading decimal point; however, this
|
||
// case is already accounted for by the parser.
|
||
if (source.charCodeAt(Index) == 46) {
|
||
position = ++Index;
|
||
// Parse the decimal component.
|
||
for (; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);
|
||
if (position == Index) {
|
||
// Illegal trailing decimal.
|
||
abort();
|
||
}
|
||
Index = position;
|
||
}
|
||
// Parse exponents. The `e` denoting the exponent is
|
||
// case-insensitive.
|
||
charCode = source.charCodeAt(Index);
|
||
if (charCode == 101 || charCode == 69) {
|
||
charCode = source.charCodeAt(++Index);
|
||
// Skip past the sign following the exponent, if one is
|
||
// specified.
|
||
if (charCode == 43 || charCode == 45) {
|
||
Index++;
|
||
}
|
||
// Parse the exponential component.
|
||
for (position = Index; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);
|
||
if (position == Index) {
|
||
// Illegal empty exponent.
|
||
abort();
|
||
}
|
||
Index = position;
|
||
}
|
||
// Coerce the parsed value to a JavaScript number.
|
||
return +source.slice(begin, Index);
|
||
}
|
||
// A negative sign may only precede numbers.
|
||
if (isSigned) {
|
||
abort();
|
||
}
|
||
// `true`, `false`, and `null` literals.
|
||
if (source.slice(Index, Index + 4) == "true") {
|
||
Index += 4;
|
||
return true;
|
||
} else if (source.slice(Index, Index + 5) == "false") {
|
||
Index += 5;
|
||
return false;
|
||
} else if (source.slice(Index, Index + 4) == "null") {
|
||
Index += 4;
|
||
return null;
|
||
}
|
||
// Unrecognized token.
|
||
abort();
|
||
}
|
||
}
|
||
// Return the sentinel `$` character if the parser has reached the end
|
||
// of the source string.
|
||
return "$";
|
||
};
|
||
|
||
// Internal: Parses a JSON `value` token.
|
||
var get = function (value) {
|
||
var results, hasMembers;
|
||
if (value == "$") {
|
||
// Unexpected end of input.
|
||
abort();
|
||
}
|
||
if (typeof value == "string") {
|
||
if ((charIndexBuggy ? value.charAt(0) : value[0]) == "@") {
|
||
// Remove the sentinel `@` character.
|
||
return value.slice(1);
|
||
}
|
||
// Parse object and array literals.
|
||
if (value == "[") {
|
||
// Parses a JSON array, returning a new JavaScript array.
|
||
results = [];
|
||
for (;; hasMembers || (hasMembers = true)) {
|
||
value = lex();
|
||
// A closing square bracket marks the end of the array literal.
|
||
if (value == "]") {
|
||
break;
|
||
}
|
||
// If the array literal contains elements, the current token
|
||
// should be a comma separating the previous element from the
|
||
// next.
|
||
if (hasMembers) {
|
||
if (value == ",") {
|
||
value = lex();
|
||
if (value == "]") {
|
||
// Unexpected trailing `,` in array literal.
|
||
abort();
|
||
}
|
||
} else {
|
||
// A `,` must separate each array element.
|
||
abort();
|
||
}
|
||
}
|
||
// Elisions and leading commas are not permitted.
|
||
if (value == ",") {
|
||
abort();
|
||
}
|
||
results.push(get(value));
|
||
}
|
||
return results;
|
||
} else if (value == "{") {
|
||
// Parses a JSON object, returning a new JavaScript object.
|
||
results = {};
|
||
for (;; hasMembers || (hasMembers = true)) {
|
||
value = lex();
|
||
// A closing curly brace marks the end of the object literal.
|
||
if (value == "}") {
|
||
break;
|
||
}
|
||
// If the object literal contains members, the current token
|
||
// should be a comma separator.
|
||
if (hasMembers) {
|
||
if (value == ",") {
|
||
value = lex();
|
||
if (value == "}") {
|
||
// Unexpected trailing `,` in object literal.
|
||
abort();
|
||
}
|
||
} else {
|
||
// A `,` must separate each object member.
|
||
abort();
|
||
}
|
||
}
|
||
// Leading commas are not permitted, object property names must be
|
||
// double-quoted strings, and a `:` must separate each property
|
||
// name and value.
|
||
if (value == "," || typeof value != "string" || (charIndexBuggy ? value.charAt(0) : value[0]) != "@" || lex() != ":") {
|
||
abort();
|
||
}
|
||
results[value.slice(1)] = get(lex());
|
||
}
|
||
return results;
|
||
}
|
||
// Unexpected token encountered.
|
||
abort();
|
||
}
|
||
return value;
|
||
};
|
||
|
||
// Internal: Updates a traversed object member.
|
||
var update = function (source, property, callback) {
|
||
var element = walk(source, property, callback);
|
||
if (element === undef) {
|
||
delete source[property];
|
||
} else {
|
||
source[property] = element;
|
||
}
|
||
};
|
||
|
||
// Internal: Recursively traverses a parsed JSON object, invoking the
|
||
// `callback` function for each value. This is an implementation of the
|
||
// `Walk(holder, name)` operation defined in ES 5.1 section 15.12.2.
|
||
var walk = function (source, property, callback) {
|
||
var value = source[property], length;
|
||
if (typeof value == "object" && value) {
|
||
// `forEach` can't be used to traverse an array in Opera <= 8.54
|
||
// because its `Object#hasOwnProperty` implementation returns `false`
|
||
// for array indices (e.g., `![1, 2, 3].hasOwnProperty("0")`).
|
||
if (getClass.call(value) == arrayClass) {
|
||
for (length = value.length; length--;) {
|
||
update(value, length, callback);
|
||
}
|
||
} else {
|
||
forEach(value, function (property) {
|
||
update(value, property, callback);
|
||
});
|
||
}
|
||
}
|
||
return callback.call(source, property, value);
|
||
};
|
||
|
||
// Public: `JSON.parse`. See ES 5.1 section 15.12.2.
|
||
exports.parse = function (source, callback) {
|
||
var result, value;
|
||
Index = 0;
|
||
Source = "" + source;
|
||
result = get(lex());
|
||
// If a JSON string contains multiple tokens, it is invalid.
|
||
if (lex() != "$") {
|
||
abort();
|
||
}
|
||
// Reset the parser state.
|
||
Index = Source = null;
|
||
return callback && getClass.call(callback) == functionClass ? walk((value = {}, value[""] = result, value), "", callback) : result;
|
||
};
|
||
}
|
||
}
|
||
|
||
exports["runInContext"] = runInContext;
|
||
return exports;
|
||
}
|
||
|
||
if (freeExports && !isLoader) {
|
||
// Export for CommonJS environments.
|
||
runInContext(root, freeExports);
|
||
} else {
|
||
// Export for web browsers and JavaScript engines.
|
||
var nativeJSON = root.JSON,
|
||
previousJSON = root["JSON3"],
|
||
isRestored = false;
|
||
|
||
var JSON3 = runInContext(root, (root["JSON3"] = {
|
||
// Public: Restores the original value of the global `JSON` object and
|
||
// returns a reference to the `JSON3` object.
|
||
"noConflict": function () {
|
||
if (!isRestored) {
|
||
isRestored = true;
|
||
root.JSON = nativeJSON;
|
||
root["JSON3"] = previousJSON;
|
||
nativeJSON = previousJSON = null;
|
||
}
|
||
return JSON3;
|
||
}
|
||
}));
|
||
|
||
root.JSON = {
|
||
"parse": JSON3.parse,
|
||
"stringify": JSON3.stringify
|
||
};
|
||
}
|
||
|
||
// Export for asynchronous module loaders.
|
||
if (isLoader) {
|
||
define(function () {
|
||
return JSON3;
|
||
});
|
||
}
|
||
}).call(this);
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],148:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/to-array/index.js", module);
|
||
(function(){
|
||
module.exports = toArray
|
||
|
||
function toArray(list, index) {
|
||
var array = []
|
||
|
||
index = index || 0
|
||
|
||
for (var i = index || 0; i < list.length; i++) {
|
||
array[i - index] = list[i]
|
||
}
|
||
|
||
return array
|
||
}
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],149:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/utf8/utf8.js", module);
|
||
(function(){
|
||
(function (global){
|
||
/*! https://mths.be/utf8js v2.0.0 by @mathias */
|
||
;(function(root) {
|
||
|
||
// Detect free variables `exports`
|
||
var freeExports = typeof exports == 'object' && exports;
|
||
|
||
// Detect free variable `module`
|
||
var freeModule = typeof module == 'object' && module &&
|
||
module.exports == freeExports && module;
|
||
|
||
// Detect free variable `global`, from Node.js or Browserified code,
|
||
// and use it as `root`
|
||
var freeGlobal = typeof global == 'object' && global;
|
||
if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
|
||
root = freeGlobal;
|
||
}
|
||
|
||
/*--------------------------------------------------------------------------*/
|
||
|
||
var stringFromCharCode = String.fromCharCode;
|
||
|
||
// Taken from https://mths.be/punycode
|
||
function ucs2decode(string) {
|
||
var output = [];
|
||
var counter = 0;
|
||
var length = string.length;
|
||
var value;
|
||
var extra;
|
||
while (counter < length) {
|
||
value = string.charCodeAt(counter++);
|
||
if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
|
||
// high surrogate, and there is a next character
|
||
extra = string.charCodeAt(counter++);
|
||
if ((extra & 0xFC00) == 0xDC00) { // low surrogate
|
||
output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
|
||
} else {
|
||
// unmatched surrogate; only append this code unit, in case the next
|
||
// code unit is the high surrogate of a surrogate pair
|
||
output.push(value);
|
||
counter--;
|
||
}
|
||
} else {
|
||
output.push(value);
|
||
}
|
||
}
|
||
return output;
|
||
}
|
||
|
||
// Taken from https://mths.be/punycode
|
||
function ucs2encode(array) {
|
||
var length = array.length;
|
||
var index = -1;
|
||
var value;
|
||
var output = '';
|
||
while (++index < length) {
|
||
value = array[index];
|
||
if (value > 0xFFFF) {
|
||
value -= 0x10000;
|
||
output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
|
||
value = 0xDC00 | value & 0x3FF;
|
||
}
|
||
output += stringFromCharCode(value);
|
||
}
|
||
return output;
|
||
}
|
||
|
||
function checkScalarValue(codePoint) {
|
||
if (codePoint >= 0xD800 && codePoint <= 0xDFFF) {
|
||
throw Error(
|
||
'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +
|
||
' is not a scalar value'
|
||
);
|
||
}
|
||
}
|
||
/*--------------------------------------------------------------------------*/
|
||
|
||
function createByte(codePoint, shift) {
|
||
return stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);
|
||
}
|
||
|
||
function encodeCodePoint(codePoint) {
|
||
if ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence
|
||
return stringFromCharCode(codePoint);
|
||
}
|
||
var symbol = '';
|
||
if ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence
|
||
symbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);
|
||
}
|
||
else if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence
|
||
checkScalarValue(codePoint);
|
||
symbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);
|
||
symbol += createByte(codePoint, 6);
|
||
}
|
||
else if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence
|
||
symbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);
|
||
symbol += createByte(codePoint, 12);
|
||
symbol += createByte(codePoint, 6);
|
||
}
|
||
symbol += stringFromCharCode((codePoint & 0x3F) | 0x80);
|
||
return symbol;
|
||
}
|
||
|
||
function utf8encode(string) {
|
||
var codePoints = ucs2decode(string);
|
||
var length = codePoints.length;
|
||
var index = -1;
|
||
var codePoint;
|
||
var byteString = '';
|
||
while (++index < length) {
|
||
codePoint = codePoints[index];
|
||
byteString += encodeCodePoint(codePoint);
|
||
}
|
||
return byteString;
|
||
}
|
||
|
||
/*--------------------------------------------------------------------------*/
|
||
|
||
function readContinuationByte() {
|
||
if (byteIndex >= byteCount) {
|
||
throw Error('Invalid byte index');
|
||
}
|
||
|
||
var continuationByte = byteArray[byteIndex] & 0xFF;
|
||
byteIndex++;
|
||
|
||
if ((continuationByte & 0xC0) == 0x80) {
|
||
return continuationByte & 0x3F;
|
||
}
|
||
|
||
// If we end up here, it’s not a continuation byte
|
||
throw Error('Invalid continuation byte');
|
||
}
|
||
|
||
function decodeSymbol() {
|
||
var byte1;
|
||
var byte2;
|
||
var byte3;
|
||
var byte4;
|
||
var codePoint;
|
||
|
||
if (byteIndex > byteCount) {
|
||
throw Error('Invalid byte index');
|
||
}
|
||
|
||
if (byteIndex == byteCount) {
|
||
return false;
|
||
}
|
||
|
||
// Read first byte
|
||
byte1 = byteArray[byteIndex] & 0xFF;
|
||
byteIndex++;
|
||
|
||
// 1-byte sequence (no continuation bytes)
|
||
if ((byte1 & 0x80) == 0) {
|
||
return byte1;
|
||
}
|
||
|
||
// 2-byte sequence
|
||
if ((byte1 & 0xE0) == 0xC0) {
|
||
var byte2 = readContinuationByte();
|
||
codePoint = ((byte1 & 0x1F) << 6) | byte2;
|
||
if (codePoint >= 0x80) {
|
||
return codePoint;
|
||
} else {
|
||
throw Error('Invalid continuation byte');
|
||
}
|
||
}
|
||
|
||
// 3-byte sequence (may include unpaired surrogates)
|
||
if ((byte1 & 0xF0) == 0xE0) {
|
||
byte2 = readContinuationByte();
|
||
byte3 = readContinuationByte();
|
||
codePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;
|
||
if (codePoint >= 0x0800) {
|
||
checkScalarValue(codePoint);
|
||
return codePoint;
|
||
} else {
|
||
throw Error('Invalid continuation byte');
|
||
}
|
||
}
|
||
|
||
// 4-byte sequence
|
||
if ((byte1 & 0xF8) == 0xF0) {
|
||
byte2 = readContinuationByte();
|
||
byte3 = readContinuationByte();
|
||
byte4 = readContinuationByte();
|
||
codePoint = ((byte1 & 0x0F) << 0x12) | (byte2 << 0x0C) |
|
||
(byte3 << 0x06) | byte4;
|
||
if (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {
|
||
return codePoint;
|
||
}
|
||
}
|
||
|
||
throw Error('Invalid UTF-8 detected');
|
||
}
|
||
|
||
var byteArray;
|
||
var byteCount;
|
||
var byteIndex;
|
||
function utf8decode(byteString) {
|
||
byteArray = ucs2decode(byteString);
|
||
byteCount = byteArray.length;
|
||
byteIndex = 0;
|
||
var codePoints = [];
|
||
var tmp;
|
||
while ((tmp = decodeSymbol()) !== false) {
|
||
codePoints.push(tmp);
|
||
}
|
||
return ucs2encode(codePoints);
|
||
}
|
||
|
||
/*--------------------------------------------------------------------------*/
|
||
|
||
var utf8 = {
|
||
'version': '2.0.0',
|
||
'encode': utf8encode,
|
||
'decode': utf8decode
|
||
};
|
||
|
||
// Some AMD build optimizers, like r.js, check for specific condition patterns
|
||
// like the following:
|
||
if (
|
||
typeof define == 'function' &&
|
||
typeof define.amd == 'object' &&
|
||
define.amd
|
||
) {
|
||
define(function() {
|
||
return utf8;
|
||
});
|
||
} else if (freeExports && !freeExports.nodeType) {
|
||
if (freeModule) { // in Node.js or RingoJS v0.8.0+
|
||
freeModule.exports = utf8;
|
||
} else { // in Narwhal or RingoJS v0.7.0-
|
||
var object = {};
|
||
var hasOwnProperty = object.hasOwnProperty;
|
||
for (var key in utf8) {
|
||
hasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);
|
||
}
|
||
}
|
||
} else { // in Rhino or a web browser
|
||
root.utf8 = utf8;
|
||
}
|
||
|
||
}(this));
|
||
|
||
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],150:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/vue-hot-reload-api/index.js", module);
|
||
(function(){
|
||
var Vue // late bind
|
||
var map = Object.create(null)
|
||
var shimmed = false
|
||
var isBrowserify = false
|
||
|
||
/**
|
||
* Determine compatibility and apply patch.
|
||
*
|
||
* @param {Function} vue
|
||
* @param {Boolean} browserify
|
||
*/
|
||
|
||
exports.install = function (vue, browserify) {
|
||
if (shimmed) return
|
||
shimmed = true
|
||
|
||
Vue = vue
|
||
isBrowserify = browserify
|
||
|
||
exports.compatible = !!Vue.internalDirectives
|
||
if (!exports.compatible) {
|
||
console.warn(
|
||
'[HMR] vue-loader hot reload is only compatible with ' +
|
||
'Vue.js 1.0.0+.'
|
||
)
|
||
return
|
||
}
|
||
|
||
// patch view directive
|
||
patchView(Vue.internalDirectives.component)
|
||
console.log('[HMR] Vue component hot reload shim applied.')
|
||
// shim router-view if present
|
||
var routerView = Vue.elementDirective('router-view')
|
||
if (routerView) {
|
||
patchView(routerView)
|
||
console.log('[HMR] vue-router <router-view> hot reload shim applied.')
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Shim the view directive (component or router-view).
|
||
*
|
||
* @param {Object} View
|
||
*/
|
||
|
||
function patchView (View) {
|
||
var unbuild = View.unbuild
|
||
View.unbuild = function (defer) {
|
||
if (!this.hotUpdating) {
|
||
var prevComponent = this.childVM && this.childVM.constructor
|
||
removeView(prevComponent, this)
|
||
// defer = true means we are transitioning to a new
|
||
// Component. Register this new component to the list.
|
||
if (defer) {
|
||
addView(this.Component, this)
|
||
}
|
||
}
|
||
// call original
|
||
return unbuild.call(this, defer)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Add a component view to a Component's hot list
|
||
*
|
||
* @param {Function} Component
|
||
* @param {Directive} view - view directive instance
|
||
*/
|
||
|
||
function addView (Component, view) {
|
||
var id = Component && Component.options.hotID
|
||
if (id) {
|
||
if (!map[id]) {
|
||
map[id] = {
|
||
Component: Component,
|
||
views: [],
|
||
instances: []
|
||
}
|
||
}
|
||
map[id].views.push(view)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Remove a component view from a Component's hot list
|
||
*
|
||
* @param {Function} Component
|
||
* @param {Directive} view - view directive instance
|
||
*/
|
||
|
||
function removeView (Component, view) {
|
||
var id = Component && Component.options.hotID
|
||
if (id) {
|
||
map[id].views.$remove(view)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Create a record for a hot module, which keeps track of its construcotr,
|
||
* instnaces and views (component directives or router-views).
|
||
*
|
||
* @param {String} id
|
||
* @param {Object} options
|
||
*/
|
||
|
||
exports.createRecord = function (id, options) {
|
||
if (typeof options === 'function') {
|
||
options = options.options
|
||
}
|
||
if (typeof options.el !== 'string' && typeof options.data !== 'object') {
|
||
makeOptionsHot(id, options)
|
||
map[id] = {
|
||
Component: null,
|
||
views: [],
|
||
instances: []
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Make a Component options object hot.
|
||
*
|
||
* @param {String} id
|
||
* @param {Object} options
|
||
*/
|
||
|
||
function makeOptionsHot (id, options) {
|
||
options.hotID = id
|
||
injectHook(options, 'created', function () {
|
||
var record = map[id]
|
||
if (!record.Component) {
|
||
record.Component = this.constructor
|
||
}
|
||
record.instances.push(this)
|
||
})
|
||
injectHook(options, 'beforeDestroy', function () {
|
||
map[id].instances.$remove(this)
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Inject a hook to a hot reloadable component so that
|
||
* we can keep track of it.
|
||
*
|
||
* @param {Object} options
|
||
* @param {String} name
|
||
* @param {Function} hook
|
||
*/
|
||
|
||
function injectHook (options, name, hook) {
|
||
var existing = options[name]
|
||
options[name] = existing
|
||
? Array.isArray(existing)
|
||
? existing.concat(hook)
|
||
: [existing, hook]
|
||
: [hook]
|
||
}
|
||
|
||
/**
|
||
* Update a hot component.
|
||
*
|
||
* @param {String} id
|
||
* @param {Object|null} newOptions
|
||
* @param {String|null} newTemplate
|
||
*/
|
||
|
||
exports.update = function (id, newOptions, newTemplate) {
|
||
var record = map[id]
|
||
// force full-reload if an instance of the component is active but is not
|
||
// managed by a view
|
||
if (!record || (record.instances.length && !record.views.length)) {
|
||
console.log('[HMR] Root or manually-mounted instance modified. Full reload may be required.')
|
||
if (!isBrowserify) {
|
||
window.location.reload()
|
||
} else {
|
||
// browserify-hmr somehow sends incomplete bundle if we reload here
|
||
return
|
||
}
|
||
}
|
||
if (!isBrowserify) {
|
||
// browserify-hmr already logs this
|
||
console.log('[HMR] Updating component: ' + format(id))
|
||
}
|
||
var Component = record.Component
|
||
// update constructor
|
||
if (newOptions) {
|
||
// in case the user exports a constructor
|
||
Component = record.Component = typeof newOptions === 'function'
|
||
? newOptions
|
||
: Vue.extend(newOptions)
|
||
makeOptionsHot(id, Component.options)
|
||
}
|
||
if (newTemplate) {
|
||
Component.options.template = newTemplate
|
||
}
|
||
// handle recursive lookup
|
||
if (Component.options.name) {
|
||
Component.options.components[Component.options.name] = Component
|
||
}
|
||
// reset constructor cached linker
|
||
Component.linker = null
|
||
// reload all views
|
||
record.views.forEach(function (view) {
|
||
updateView(view, Component)
|
||
})
|
||
// flush devtools
|
||
if (window.__VUE_DEVTOOLS_GLOBAL_HOOK__) {
|
||
window.__VUE_DEVTOOLS_GLOBAL_HOOK__.emit('flush')
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Update a component view instance
|
||
*
|
||
* @param {Directive} view
|
||
* @param {Function} Component
|
||
*/
|
||
|
||
function updateView (view, Component) {
|
||
if (!view._bound) {
|
||
return
|
||
}
|
||
view.Component = Component
|
||
view.hotUpdating = true
|
||
// disable transitions
|
||
view.vm._isCompiled = false
|
||
// save state
|
||
var state = extractState(view.childVM)
|
||
// remount, make sure to disable keep-alive
|
||
var keepAlive = view.keepAlive
|
||
view.keepAlive = false
|
||
view.mountComponent()
|
||
view.keepAlive = keepAlive
|
||
// restore state
|
||
restoreState(view.childVM, state, true)
|
||
// re-eanble transitions
|
||
view.vm._isCompiled = true
|
||
view.hotUpdating = false
|
||
}
|
||
|
||
/**
|
||
* Extract state from a Vue instance.
|
||
*
|
||
* @param {Vue} vm
|
||
* @return {Object}
|
||
*/
|
||
|
||
function extractState (vm) {
|
||
return {
|
||
cid: vm.constructor.cid,
|
||
data: vm.$data,
|
||
children: vm.$children.map(extractState)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Restore state to a reloaded Vue instance.
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {Object} state
|
||
*/
|
||
|
||
function restoreState (vm, state, isRoot) {
|
||
var oldAsyncConfig
|
||
if (isRoot) {
|
||
// set Vue into sync mode during state rehydration
|
||
oldAsyncConfig = Vue.config.async
|
||
Vue.config.async = false
|
||
}
|
||
// actual restore
|
||
if (isRoot || !vm._props) {
|
||
vm.$data = state.data
|
||
} else {
|
||
Object.keys(state.data).forEach(function (key) {
|
||
if (!vm._props[key]) {
|
||
// for non-root, only restore non-props fields
|
||
vm.$data[key] = state.data[key]
|
||
}
|
||
})
|
||
}
|
||
// verify child consistency
|
||
var hasSameChildren = vm.$children.every(function (c, i) {
|
||
return state.children[i] && state.children[i].cid === c.constructor.cid
|
||
})
|
||
if (hasSameChildren) {
|
||
// rehydrate children
|
||
vm.$children.forEach(function (c, i) {
|
||
restoreState(c, state.children[i])
|
||
})
|
||
}
|
||
if (isRoot) {
|
||
Vue.config.async = oldAsyncConfig
|
||
}
|
||
}
|
||
|
||
function format (id) {
|
||
return id.match(/[^\/]+\.vue$/)[0]
|
||
}
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],151:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/vue/dist/vue.common.js", module);
|
||
(function(){
|
||
(function (process,global){
|
||
/*!
|
||
* Vue.js v1.0.17
|
||
* (c) 2016 Evan You
|
||
* Released under the MIT License.
|
||
*/
|
||
'use strict';
|
||
|
||
function set(obj, key, val) {
|
||
if (hasOwn(obj, key)) {
|
||
obj[key] = val;
|
||
return;
|
||
}
|
||
if (obj._isVue) {
|
||
set(obj._data, key, val);
|
||
return;
|
||
}
|
||
var ob = obj.__ob__;
|
||
if (!ob) {
|
||
obj[key] = val;
|
||
return;
|
||
}
|
||
ob.convert(key, val);
|
||
ob.dep.notify();
|
||
if (ob.vms) {
|
||
var i = ob.vms.length;
|
||
while (i--) {
|
||
var vm = ob.vms[i];
|
||
vm._proxy(key);
|
||
vm._digest();
|
||
}
|
||
}
|
||
return val;
|
||
}
|
||
|
||
/**
|
||
* Delete a property and trigger change if necessary.
|
||
*
|
||
* @param {Object} obj
|
||
* @param {String} key
|
||
*/
|
||
|
||
function del(obj, key) {
|
||
if (!hasOwn(obj, key)) {
|
||
return;
|
||
}
|
||
delete obj[key];
|
||
var ob = obj.__ob__;
|
||
if (!ob) {
|
||
return;
|
||
}
|
||
ob.dep.notify();
|
||
if (ob.vms) {
|
||
var i = ob.vms.length;
|
||
while (i--) {
|
||
var vm = ob.vms[i];
|
||
vm._unproxy(key);
|
||
vm._digest();
|
||
}
|
||
}
|
||
}
|
||
|
||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||
/**
|
||
* Check whether the object has the property.
|
||
*
|
||
* @param {Object} obj
|
||
* @param {String} key
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
function hasOwn(obj, key) {
|
||
return hasOwnProperty.call(obj, key);
|
||
}
|
||
|
||
/**
|
||
* Check if an expression is a literal value.
|
||
*
|
||
* @param {String} exp
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
var literalValueRE = /^\s?(true|false|-?[\d\.]+|'[^']*'|"[^"]*")\s?$/;
|
||
|
||
function isLiteral(exp) {
|
||
return literalValueRE.test(exp);
|
||
}
|
||
|
||
/**
|
||
* Check if a string starts with $ or _
|
||
*
|
||
* @param {String} str
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
function isReserved(str) {
|
||
var c = (str + '').charCodeAt(0);
|
||
return c === 0x24 || c === 0x5F;
|
||
}
|
||
|
||
/**
|
||
* Guard text output, make sure undefined outputs
|
||
* empty string
|
||
*
|
||
* @param {*} value
|
||
* @return {String}
|
||
*/
|
||
|
||
function _toString(value) {
|
||
return value == null ? '' : value.toString();
|
||
}
|
||
|
||
/**
|
||
* Check and convert possible numeric strings to numbers
|
||
* before setting back to data
|
||
*
|
||
* @param {*} value
|
||
* @return {*|Number}
|
||
*/
|
||
|
||
function toNumber(value) {
|
||
if (typeof value !== 'string') {
|
||
return value;
|
||
} else {
|
||
var parsed = Number(value);
|
||
return isNaN(parsed) ? value : parsed;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Convert string boolean literals into real booleans.
|
||
*
|
||
* @param {*} value
|
||
* @return {*|Boolean}
|
||
*/
|
||
|
||
function toBoolean(value) {
|
||
return value === 'true' ? true : value === 'false' ? false : value;
|
||
}
|
||
|
||
/**
|
||
* Strip quotes from a string
|
||
*
|
||
* @param {String} str
|
||
* @return {String | false}
|
||
*/
|
||
|
||
function stripQuotes(str) {
|
||
var a = str.charCodeAt(0);
|
||
var b = str.charCodeAt(str.length - 1);
|
||
return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;
|
||
}
|
||
|
||
/**
|
||
* Camelize a hyphen-delmited string.
|
||
*
|
||
* @param {String} str
|
||
* @return {String}
|
||
*/
|
||
|
||
var camelizeRE = /-(\w)/g;
|
||
|
||
function camelize(str) {
|
||
return str.replace(camelizeRE, toUpper);
|
||
}
|
||
|
||
function toUpper(_, c) {
|
||
return c ? c.toUpperCase() : '';
|
||
}
|
||
|
||
/**
|
||
* Hyphenate a camelCase string.
|
||
*
|
||
* @param {String} str
|
||
* @return {String}
|
||
*/
|
||
|
||
var hyphenateRE = /([a-z\d])([A-Z])/g;
|
||
|
||
function hyphenate(str) {
|
||
return str.replace(hyphenateRE, '$1-$2').toLowerCase();
|
||
}
|
||
|
||
/**
|
||
* Converts hyphen/underscore/slash delimitered names into
|
||
* camelized classNames.
|
||
*
|
||
* e.g. my-component => MyComponent
|
||
* some_else => SomeElse
|
||
* some/comp => SomeComp
|
||
*
|
||
* @param {String} str
|
||
* @return {String}
|
||
*/
|
||
|
||
var classifyRE = /(?:^|[-_\/])(\w)/g;
|
||
|
||
function classify(str) {
|
||
return str.replace(classifyRE, toUpper);
|
||
}
|
||
|
||
/**
|
||
* Simple bind, faster than native
|
||
*
|
||
* @param {Function} fn
|
||
* @param {Object} ctx
|
||
* @return {Function}
|
||
*/
|
||
|
||
function bind(fn, ctx) {
|
||
return function (a) {
|
||
var l = arguments.length;
|
||
return l ? l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a) : fn.call(ctx);
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Convert an Array-like object to a real Array.
|
||
*
|
||
* @param {Array-like} list
|
||
* @param {Number} [start] - start index
|
||
* @return {Array}
|
||
*/
|
||
|
||
function toArray(list, start) {
|
||
start = start || 0;
|
||
var i = list.length - start;
|
||
var ret = new Array(i);
|
||
while (i--) {
|
||
ret[i] = list[i + start];
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
/**
|
||
* Mix properties into target object.
|
||
*
|
||
* @param {Object} to
|
||
* @param {Object} from
|
||
*/
|
||
|
||
function extend(to, from) {
|
||
var keys = Object.keys(from);
|
||
var i = keys.length;
|
||
while (i--) {
|
||
to[keys[i]] = from[keys[i]];
|
||
}
|
||
return to;
|
||
}
|
||
|
||
/**
|
||
* Quick object check - this is primarily used to tell
|
||
* Objects from primitive values when we know the value
|
||
* is a JSON-compliant type.
|
||
*
|
||
* @param {*} obj
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
function isObject(obj) {
|
||
return obj !== null && typeof obj === 'object';
|
||
}
|
||
|
||
/**
|
||
* Strict object type check. Only returns true
|
||
* for plain JavaScript objects.
|
||
*
|
||
* @param {*} obj
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
var toString = Object.prototype.toString;
|
||
var OBJECT_STRING = '[object Object]';
|
||
|
||
function isPlainObject(obj) {
|
||
return toString.call(obj) === OBJECT_STRING;
|
||
}
|
||
|
||
/**
|
||
* Array type check.
|
||
*
|
||
* @param {*} obj
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
var isArray = Array.isArray;
|
||
|
||
/**
|
||
* Define a non-enumerable property
|
||
*
|
||
* @param {Object} obj
|
||
* @param {String} key
|
||
* @param {*} val
|
||
* @param {Boolean} [enumerable]
|
||
*/
|
||
|
||
function def(obj, key, val, enumerable) {
|
||
Object.defineProperty(obj, key, {
|
||
value: val,
|
||
enumerable: !!enumerable,
|
||
writable: true,
|
||
configurable: true
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Debounce a function so it only gets called after the
|
||
* input stops arriving after the given wait period.
|
||
*
|
||
* @param {Function} func
|
||
* @param {Number} wait
|
||
* @return {Function} - the debounced function
|
||
*/
|
||
|
||
function _debounce(func, wait) {
|
||
var timeout, args, context, timestamp, result;
|
||
var later = function later() {
|
||
var last = Date.now() - timestamp;
|
||
if (last < wait && last >= 0) {
|
||
timeout = setTimeout(later, wait - last);
|
||
} else {
|
||
timeout = null;
|
||
result = func.apply(context, args);
|
||
if (!timeout) context = args = null;
|
||
}
|
||
};
|
||
return function () {
|
||
context = this;
|
||
args = arguments;
|
||
timestamp = Date.now();
|
||
if (!timeout) {
|
||
timeout = setTimeout(later, wait);
|
||
}
|
||
return result;
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Manual indexOf because it's slightly faster than
|
||
* native.
|
||
*
|
||
* @param {Array} arr
|
||
* @param {*} obj
|
||
*/
|
||
|
||
function indexOf(arr, obj) {
|
||
var i = arr.length;
|
||
while (i--) {
|
||
if (arr[i] === obj) return i;
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
/**
|
||
* Make a cancellable version of an async callback.
|
||
*
|
||
* @param {Function} fn
|
||
* @return {Function}
|
||
*/
|
||
|
||
function cancellable(fn) {
|
||
var cb = function cb() {
|
||
if (!cb.cancelled) {
|
||
return fn.apply(this, arguments);
|
||
}
|
||
};
|
||
cb.cancel = function () {
|
||
cb.cancelled = true;
|
||
};
|
||
return cb;
|
||
}
|
||
|
||
/**
|
||
* Check if two values are loosely equal - that is,
|
||
* if they are plain objects, do they have the same shape?
|
||
*
|
||
* @param {*} a
|
||
* @param {*} b
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
function looseEqual(a, b) {
|
||
/* eslint-disable eqeqeq */
|
||
return a == b || (isObject(a) && isObject(b) ? JSON.stringify(a) === JSON.stringify(b) : false);
|
||
/* eslint-enable eqeqeq */
|
||
}
|
||
|
||
var hasProto = ('__proto__' in {});
|
||
|
||
// Browser environment sniffing
|
||
var inBrowser = typeof window !== 'undefined' && Object.prototype.toString.call(window) !== '[object Object]';
|
||
|
||
// detect devtools
|
||
var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
|
||
|
||
// UA sniffing for working around browser-specific quirks
|
||
var UA = inBrowser && window.navigator.userAgent.toLowerCase();
|
||
var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
|
||
var isAndroid = UA && UA.indexOf('android') > 0;
|
||
|
||
var transitionProp = undefined;
|
||
var transitionEndEvent = undefined;
|
||
var animationProp = undefined;
|
||
var animationEndEvent = undefined;
|
||
|
||
// Transition property/event sniffing
|
||
if (inBrowser && !isIE9) {
|
||
var isWebkitTrans = window.ontransitionend === undefined && window.onwebkittransitionend !== undefined;
|
||
var isWebkitAnim = window.onanimationend === undefined && window.onwebkitanimationend !== undefined;
|
||
transitionProp = isWebkitTrans ? 'WebkitTransition' : 'transition';
|
||
transitionEndEvent = isWebkitTrans ? 'webkitTransitionEnd' : 'transitionend';
|
||
animationProp = isWebkitAnim ? 'WebkitAnimation' : 'animation';
|
||
animationEndEvent = isWebkitAnim ? 'webkitAnimationEnd' : 'animationend';
|
||
}
|
||
|
||
/**
|
||
* Defer a task to execute it asynchronously. Ideally this
|
||
* should be executed as a microtask, so we leverage
|
||
* MutationObserver if it's available, and fallback to
|
||
* setTimeout(0).
|
||
*
|
||
* @param {Function} cb
|
||
* @param {Object} ctx
|
||
*/
|
||
|
||
var nextTick = (function () {
|
||
var callbacks = [];
|
||
var pending = false;
|
||
var timerFunc;
|
||
function nextTickHandler() {
|
||
pending = false;
|
||
var copies = callbacks.slice(0);
|
||
callbacks = [];
|
||
for (var i = 0; i < copies.length; i++) {
|
||
copies[i]();
|
||
}
|
||
}
|
||
|
||
/* istanbul ignore if */
|
||
if (typeof MutationObserver !== 'undefined') {
|
||
var counter = 1;
|
||
var observer = new MutationObserver(nextTickHandler);
|
||
var textNode = document.createTextNode(counter);
|
||
observer.observe(textNode, {
|
||
characterData: true
|
||
});
|
||
timerFunc = function () {
|
||
counter = (counter + 1) % 2;
|
||
textNode.data = counter;
|
||
};
|
||
} else {
|
||
// webpack attempts to inject a shim for setImmediate
|
||
// if it is used as a global, so we have to work around that to
|
||
// avoid bundling unnecessary code.
|
||
var context = inBrowser ? window : typeof global !== 'undefined' ? global : {};
|
||
timerFunc = context.setImmediate || setTimeout;
|
||
}
|
||
return function (cb, ctx) {
|
||
var func = ctx ? function () {
|
||
cb.call(ctx);
|
||
} : cb;
|
||
callbacks.push(func);
|
||
if (pending) return;
|
||
pending = true;
|
||
timerFunc(nextTickHandler, 0);
|
||
};
|
||
})();
|
||
|
||
function Cache(limit) {
|
||
this.size = 0;
|
||
this.limit = limit;
|
||
this.head = this.tail = undefined;
|
||
this._keymap = Object.create(null);
|
||
}
|
||
|
||
var p = Cache.prototype;
|
||
|
||
/**
|
||
* Put <value> into the cache associated with <key>.
|
||
* Returns the entry which was removed to make room for
|
||
* the new entry. Otherwise undefined is returned.
|
||
* (i.e. if there was enough room already).
|
||
*
|
||
* @param {String} key
|
||
* @param {*} value
|
||
* @return {Entry|undefined}
|
||
*/
|
||
|
||
p.put = function (key, value) {
|
||
var removed;
|
||
if (this.size === this.limit) {
|
||
removed = this.shift();
|
||
}
|
||
|
||
var entry = this.get(key, true);
|
||
if (!entry) {
|
||
entry = {
|
||
key: key
|
||
};
|
||
this._keymap[key] = entry;
|
||
if (this.tail) {
|
||
this.tail.newer = entry;
|
||
entry.older = this.tail;
|
||
} else {
|
||
this.head = entry;
|
||
}
|
||
this.tail = entry;
|
||
this.size++;
|
||
}
|
||
entry.value = value;
|
||
|
||
return removed;
|
||
};
|
||
|
||
/**
|
||
* Purge the least recently used (oldest) entry from the
|
||
* cache. Returns the removed entry or undefined if the
|
||
* cache was empty.
|
||
*/
|
||
|
||
p.shift = function () {
|
||
var entry = this.head;
|
||
if (entry) {
|
||
this.head = this.head.newer;
|
||
this.head.older = undefined;
|
||
entry.newer = entry.older = undefined;
|
||
this._keymap[entry.key] = undefined;
|
||
this.size--;
|
||
}
|
||
return entry;
|
||
};
|
||
|
||
/**
|
||
* Get and register recent use of <key>. Returns the value
|
||
* associated with <key> or undefined if not in cache.
|
||
*
|
||
* @param {String} key
|
||
* @param {Boolean} returnEntry
|
||
* @return {Entry|*}
|
||
*/
|
||
|
||
p.get = function (key, returnEntry) {
|
||
var entry = this._keymap[key];
|
||
if (entry === undefined) return;
|
||
if (entry === this.tail) {
|
||
return returnEntry ? entry : entry.value;
|
||
}
|
||
// HEAD--------------TAIL
|
||
// <.older .newer>
|
||
// <--- add direction --
|
||
// A B C <D> E
|
||
if (entry.newer) {
|
||
if (entry === this.head) {
|
||
this.head = entry.newer;
|
||
}
|
||
entry.newer.older = entry.older; // C <-- E.
|
||
}
|
||
if (entry.older) {
|
||
entry.older.newer = entry.newer; // C. --> E
|
||
}
|
||
entry.newer = undefined; // D --x
|
||
entry.older = this.tail; // D. --> E
|
||
if (this.tail) {
|
||
this.tail.newer = entry; // E. <-- D
|
||
}
|
||
this.tail = entry;
|
||
return returnEntry ? entry : entry.value;
|
||
};
|
||
|
||
var cache$1 = new Cache(1000);
|
||
var filterTokenRE = /[^\s'"]+|'[^']*'|"[^"]*"/g;
|
||
var reservedArgRE = /^in$|^-?\d+/;
|
||
|
||
/**
|
||
* Parser state
|
||
*/
|
||
|
||
var str;
|
||
var dir;
|
||
var c;
|
||
var prev;
|
||
var i;
|
||
var l;
|
||
var lastFilterIndex;
|
||
var inSingle;
|
||
var inDouble;
|
||
var curly;
|
||
var square;
|
||
var paren;
|
||
/**
|
||
* Push a filter to the current directive object
|
||
*/
|
||
|
||
function pushFilter() {
|
||
var exp = str.slice(lastFilterIndex, i).trim();
|
||
var filter;
|
||
if (exp) {
|
||
filter = {};
|
||
var tokens = exp.match(filterTokenRE);
|
||
filter.name = tokens[0];
|
||
if (tokens.length > 1) {
|
||
filter.args = tokens.slice(1).map(processFilterArg);
|
||
}
|
||
}
|
||
if (filter) {
|
||
(dir.filters = dir.filters || []).push(filter);
|
||
}
|
||
lastFilterIndex = i + 1;
|
||
}
|
||
|
||
/**
|
||
* Check if an argument is dynamic and strip quotes.
|
||
*
|
||
* @param {String} arg
|
||
* @return {Object}
|
||
*/
|
||
|
||
function processFilterArg(arg) {
|
||
if (reservedArgRE.test(arg)) {
|
||
return {
|
||
value: toNumber(arg),
|
||
dynamic: false
|
||
};
|
||
} else {
|
||
var stripped = stripQuotes(arg);
|
||
var dynamic = stripped === arg;
|
||
return {
|
||
value: dynamic ? arg : stripped,
|
||
dynamic: dynamic
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Parse a directive value and extract the expression
|
||
* and its filters into a descriptor.
|
||
*
|
||
* Example:
|
||
*
|
||
* "a + 1 | uppercase" will yield:
|
||
* {
|
||
* expression: 'a + 1',
|
||
* filters: [
|
||
* { name: 'uppercase', args: null }
|
||
* ]
|
||
* }
|
||
*
|
||
* @param {String} str
|
||
* @return {Object}
|
||
*/
|
||
|
||
function parseDirective(s) {
|
||
var hit = cache$1.get(s);
|
||
if (hit) {
|
||
return hit;
|
||
}
|
||
|
||
// reset parser state
|
||
str = s;
|
||
inSingle = inDouble = false;
|
||
curly = square = paren = 0;
|
||
lastFilterIndex = 0;
|
||
dir = {};
|
||
|
||
for (i = 0, l = str.length; i < l; i++) {
|
||
prev = c;
|
||
c = str.charCodeAt(i);
|
||
if (inSingle) {
|
||
// check single quote
|
||
if (c === 0x27 && prev !== 0x5C) inSingle = !inSingle;
|
||
} else if (inDouble) {
|
||
// check double quote
|
||
if (c === 0x22 && prev !== 0x5C) inDouble = !inDouble;
|
||
} else if (c === 0x7C && // pipe
|
||
str.charCodeAt(i + 1) !== 0x7C && str.charCodeAt(i - 1) !== 0x7C) {
|
||
if (dir.expression == null) {
|
||
// first filter, end of expression
|
||
lastFilterIndex = i + 1;
|
||
dir.expression = str.slice(0, i).trim();
|
||
} else {
|
||
// already has filter
|
||
pushFilter();
|
||
}
|
||
} else {
|
||
switch (c) {
|
||
case 0x22:
|
||
inDouble = true;break; // "
|
||
case 0x27:
|
||
inSingle = true;break; // '
|
||
case 0x28:
|
||
paren++;break; // (
|
||
case 0x29:
|
||
paren--;break; // )
|
||
case 0x5B:
|
||
square++;break; // [
|
||
case 0x5D:
|
||
square--;break; // ]
|
||
case 0x7B:
|
||
curly++;break; // {
|
||
case 0x7D:
|
||
curly--;break; // }
|
||
}
|
||
}
|
||
}
|
||
|
||
if (dir.expression == null) {
|
||
dir.expression = str.slice(0, i).trim();
|
||
} else if (lastFilterIndex !== 0) {
|
||
pushFilter();
|
||
}
|
||
|
||
cache$1.put(s, dir);
|
||
return dir;
|
||
}
|
||
|
||
var directive = Object.freeze({
|
||
parseDirective: parseDirective
|
||
});
|
||
|
||
var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
|
||
var cache = undefined;
|
||
var tagRE = undefined;
|
||
var htmlRE = undefined;
|
||
/**
|
||
* Escape a string so it can be used in a RegExp
|
||
* constructor.
|
||
*
|
||
* @param {String} str
|
||
*/
|
||
|
||
function escapeRegex(str) {
|
||
return str.replace(regexEscapeRE, '\\$&');
|
||
}
|
||
|
||
function compileRegex() {
|
||
var open = escapeRegex(config.delimiters[0]);
|
||
var close = escapeRegex(config.delimiters[1]);
|
||
var unsafeOpen = escapeRegex(config.unsafeDelimiters[0]);
|
||
var unsafeClose = escapeRegex(config.unsafeDelimiters[1]);
|
||
tagRE = new RegExp(unsafeOpen + '(.+?)' + unsafeClose + '|' + open + '(.+?)' + close, 'g');
|
||
htmlRE = new RegExp('^' + unsafeOpen + '.*' + unsafeClose + '$');
|
||
// reset cache
|
||
cache = new Cache(1000);
|
||
}
|
||
|
||
/**
|
||
* Parse a template text string into an array of tokens.
|
||
*
|
||
* @param {String} text
|
||
* @return {Array<Object> | null}
|
||
* - {String} type
|
||
* - {String} value
|
||
* - {Boolean} [html]
|
||
* - {Boolean} [oneTime]
|
||
*/
|
||
|
||
function parseText(text) {
|
||
if (!cache) {
|
||
compileRegex();
|
||
}
|
||
var hit = cache.get(text);
|
||
if (hit) {
|
||
return hit;
|
||
}
|
||
text = text.replace(/\n/g, '');
|
||
if (!tagRE.test(text)) {
|
||
return null;
|
||
}
|
||
var tokens = [];
|
||
var lastIndex = tagRE.lastIndex = 0;
|
||
var match, index, html, value, first, oneTime;
|
||
/* eslint-disable no-cond-assign */
|
||
while (match = tagRE.exec(text)) {
|
||
/* eslint-enable no-cond-assign */
|
||
index = match.index;
|
||
// push text token
|
||
if (index > lastIndex) {
|
||
tokens.push({
|
||
value: text.slice(lastIndex, index)
|
||
});
|
||
}
|
||
// tag token
|
||
html = htmlRE.test(match[0]);
|
||
value = html ? match[1] : match[2];
|
||
first = value.charCodeAt(0);
|
||
oneTime = first === 42; // *
|
||
value = oneTime ? value.slice(1) : value;
|
||
tokens.push({
|
||
tag: true,
|
||
value: value.trim(),
|
||
html: html,
|
||
oneTime: oneTime
|
||
});
|
||
lastIndex = index + match[0].length;
|
||
}
|
||
if (lastIndex < text.length) {
|
||
tokens.push({
|
||
value: text.slice(lastIndex)
|
||
});
|
||
}
|
||
cache.put(text, tokens);
|
||
return tokens;
|
||
}
|
||
|
||
/**
|
||
* Format a list of tokens into an expression.
|
||
* e.g. tokens parsed from 'a {{b}} c' can be serialized
|
||
* into one single expression as '"a " + b + " c"'.
|
||
*
|
||
* @param {Array} tokens
|
||
* @param {Vue} [vm]
|
||
* @return {String}
|
||
*/
|
||
|
||
function tokensToExp(tokens, vm) {
|
||
if (tokens.length > 1) {
|
||
return tokens.map(function (token) {
|
||
return formatToken(token, vm);
|
||
}).join('+');
|
||
} else {
|
||
return formatToken(tokens[0], vm, true);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Format a single token.
|
||
*
|
||
* @param {Object} token
|
||
* @param {Vue} [vm]
|
||
* @param {Boolean} [single]
|
||
* @return {String}
|
||
*/
|
||
|
||
function formatToken(token, vm, single) {
|
||
return token.tag ? token.oneTime && vm ? '"' + vm.$eval(token.value) + '"' : inlineFilters(token.value, single) : '"' + token.value + '"';
|
||
}
|
||
|
||
/**
|
||
* For an attribute with multiple interpolation tags,
|
||
* e.g. attr="some-{{thing | filter}}", in order to combine
|
||
* the whole thing into a single watchable expression, we
|
||
* have to inline those filters. This function does exactly
|
||
* that. This is a bit hacky but it avoids heavy changes
|
||
* to directive parser and watcher mechanism.
|
||
*
|
||
* @param {String} exp
|
||
* @param {Boolean} single
|
||
* @return {String}
|
||
*/
|
||
|
||
var filterRE = /[^|]\|[^|]/;
|
||
function inlineFilters(exp, single) {
|
||
if (!filterRE.test(exp)) {
|
||
return single ? exp : '(' + exp + ')';
|
||
} else {
|
||
var dir = parseDirective(exp);
|
||
if (!dir.filters) {
|
||
return '(' + exp + ')';
|
||
} else {
|
||
return 'this._applyFilters(' + dir.expression + // value
|
||
',null,' + // oldValue (null for read)
|
||
JSON.stringify(dir.filters) + // filter descriptors
|
||
',false)'; // write?
|
||
}
|
||
}
|
||
}
|
||
|
||
var text = Object.freeze({
|
||
compileRegex: compileRegex,
|
||
parseText: parseText,
|
||
tokensToExp: tokensToExp
|
||
});
|
||
|
||
var delimiters = ['{{', '}}'];
|
||
var unsafeDelimiters = ['{{{', '}}}'];
|
||
|
||
var config = Object.defineProperties({
|
||
|
||
/**
|
||
* Whether to print debug messages.
|
||
* Also enables stack trace for warnings.
|
||
*
|
||
* @type {Boolean}
|
||
*/
|
||
|
||
debug: false,
|
||
|
||
/**
|
||
* Whether to suppress warnings.
|
||
*
|
||
* @type {Boolean}
|
||
*/
|
||
|
||
silent: false,
|
||
|
||
/**
|
||
* Whether to use async rendering.
|
||
*/
|
||
|
||
async: true,
|
||
|
||
/**
|
||
* Whether to warn against errors caught when evaluating
|
||
* expressions.
|
||
*/
|
||
|
||
warnExpressionErrors: true,
|
||
|
||
/**
|
||
* Internal flag to indicate the delimiters have been
|
||
* changed.
|
||
*
|
||
* @type {Boolean}
|
||
*/
|
||
|
||
_delimitersChanged: true,
|
||
|
||
/**
|
||
* List of asset types that a component can own.
|
||
*
|
||
* @type {Array}
|
||
*/
|
||
|
||
_assetTypes: ['component', 'directive', 'elementDirective', 'filter', 'transition', 'partial'],
|
||
|
||
/**
|
||
* prop binding modes
|
||
*/
|
||
|
||
_propBindingModes: {
|
||
ONE_WAY: 0,
|
||
TWO_WAY: 1,
|
||
ONE_TIME: 2
|
||
},
|
||
|
||
/**
|
||
* Max circular updates allowed in a batcher flush cycle.
|
||
*/
|
||
|
||
_maxUpdateCount: 100
|
||
|
||
}, {
|
||
delimiters: { /**
|
||
* Interpolation delimiters. Changing these would trigger
|
||
* the text parser to re-compile the regular expressions.
|
||
*
|
||
* @type {Array<String>}
|
||
*/
|
||
|
||
get: function get() {
|
||
return delimiters;
|
||
},
|
||
set: function set(val) {
|
||
delimiters = val;
|
||
compileRegex();
|
||
},
|
||
configurable: true,
|
||
enumerable: true
|
||
},
|
||
unsafeDelimiters: {
|
||
get: function get() {
|
||
return unsafeDelimiters;
|
||
},
|
||
set: function set(val) {
|
||
unsafeDelimiters = val;
|
||
compileRegex();
|
||
},
|
||
configurable: true,
|
||
enumerable: true
|
||
}
|
||
});
|
||
|
||
var warn = undefined;
|
||
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
(function () {
|
||
var hasConsole = typeof console !== 'undefined';
|
||
warn = function (msg, e) {
|
||
if (hasConsole && (!config.silent || config.debug)) {
|
||
console.warn('[Vue warn]: ' + msg);
|
||
/* istanbul ignore if */
|
||
if (config.debug) {
|
||
if (e) {
|
||
throw e;
|
||
} else {
|
||
console.warn(new Error('Warning Stack Trace').stack);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
})();
|
||
}
|
||
|
||
/**
|
||
* Append with transition.
|
||
*
|
||
* @param {Element} el
|
||
* @param {Element} target
|
||
* @param {Vue} vm
|
||
* @param {Function} [cb]
|
||
*/
|
||
|
||
function appendWithTransition(el, target, vm, cb) {
|
||
applyTransition(el, 1, function () {
|
||
target.appendChild(el);
|
||
}, vm, cb);
|
||
}
|
||
|
||
/**
|
||
* InsertBefore with transition.
|
||
*
|
||
* @param {Element} el
|
||
* @param {Element} target
|
||
* @param {Vue} vm
|
||
* @param {Function} [cb]
|
||
*/
|
||
|
||
function beforeWithTransition(el, target, vm, cb) {
|
||
applyTransition(el, 1, function () {
|
||
before(el, target);
|
||
}, vm, cb);
|
||
}
|
||
|
||
/**
|
||
* Remove with transition.
|
||
*
|
||
* @param {Element} el
|
||
* @param {Vue} vm
|
||
* @param {Function} [cb]
|
||
*/
|
||
|
||
function removeWithTransition(el, vm, cb) {
|
||
applyTransition(el, -1, function () {
|
||
remove(el);
|
||
}, vm, cb);
|
||
}
|
||
|
||
/**
|
||
* Apply transitions with an operation callback.
|
||
*
|
||
* @param {Element} el
|
||
* @param {Number} direction
|
||
* 1: enter
|
||
* -1: leave
|
||
* @param {Function} op - the actual DOM operation
|
||
* @param {Vue} vm
|
||
* @param {Function} [cb]
|
||
*/
|
||
|
||
function applyTransition(el, direction, op, vm, cb) {
|
||
var transition = el.__v_trans;
|
||
if (!transition ||
|
||
// skip if there are no js hooks and CSS transition is
|
||
// not supported
|
||
!transition.hooks && !transitionEndEvent ||
|
||
// skip transitions for initial compile
|
||
!vm._isCompiled ||
|
||
// if the vm is being manipulated by a parent directive
|
||
// during the parent's compilation phase, skip the
|
||
// animation.
|
||
vm.$parent && !vm.$parent._isCompiled) {
|
||
op();
|
||
if (cb) cb();
|
||
return;
|
||
}
|
||
var action = direction > 0 ? 'enter' : 'leave';
|
||
transition[action](op, cb);
|
||
}
|
||
|
||
var transition = Object.freeze({
|
||
appendWithTransition: appendWithTransition,
|
||
beforeWithTransition: beforeWithTransition,
|
||
removeWithTransition: removeWithTransition,
|
||
applyTransition: applyTransition
|
||
});
|
||
|
||
/**
|
||
* Query an element selector if it's not an element already.
|
||
*
|
||
* @param {String|Element} el
|
||
* @return {Element}
|
||
*/
|
||
|
||
function query(el) {
|
||
if (typeof el === 'string') {
|
||
var selector = el;
|
||
el = document.querySelector(el);
|
||
if (!el) {
|
||
process.env.NODE_ENV !== 'production' && warn('Cannot find element: ' + selector);
|
||
}
|
||
}
|
||
return el;
|
||
}
|
||
|
||
/**
|
||
* Check if a node is in the document.
|
||
* Note: document.documentElement.contains should work here
|
||
* but always returns false for comment nodes in phantomjs,
|
||
* making unit tests difficult. This is fixed by doing the
|
||
* contains() check on the node's parentNode instead of
|
||
* the node itself.
|
||
*
|
||
* @param {Node} node
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
function inDoc(node) {
|
||
var doc = document.documentElement;
|
||
var parent = node && node.parentNode;
|
||
return doc === node || doc === parent || !!(parent && parent.nodeType === 1 && doc.contains(parent));
|
||
}
|
||
|
||
/**
|
||
* Get and remove an attribute from a node.
|
||
*
|
||
* @param {Node} node
|
||
* @param {String} _attr
|
||
*/
|
||
|
||
function getAttr(node, _attr) {
|
||
var val = node.getAttribute(_attr);
|
||
if (val !== null) {
|
||
node.removeAttribute(_attr);
|
||
}
|
||
return val;
|
||
}
|
||
|
||
/**
|
||
* Get an attribute with colon or v-bind: prefix.
|
||
*
|
||
* @param {Node} node
|
||
* @param {String} name
|
||
* @return {String|null}
|
||
*/
|
||
|
||
function getBindAttr(node, name) {
|
||
var val = getAttr(node, ':' + name);
|
||
if (val === null) {
|
||
val = getAttr(node, 'v-bind:' + name);
|
||
}
|
||
return val;
|
||
}
|
||
|
||
/**
|
||
* Check the presence of a bind attribute.
|
||
*
|
||
* @param {Node} node
|
||
* @param {String} name
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
function hasBindAttr(node, name) {
|
||
return node.hasAttribute(name) || node.hasAttribute(':' + name) || node.hasAttribute('v-bind:' + name);
|
||
}
|
||
|
||
/**
|
||
* Insert el before target
|
||
*
|
||
* @param {Element} el
|
||
* @param {Element} target
|
||
*/
|
||
|
||
function before(el, target) {
|
||
target.parentNode.insertBefore(el, target);
|
||
}
|
||
|
||
/**
|
||
* Insert el after target
|
||
*
|
||
* @param {Element} el
|
||
* @param {Element} target
|
||
*/
|
||
|
||
function after(el, target) {
|
||
if (target.nextSibling) {
|
||
before(el, target.nextSibling);
|
||
} else {
|
||
target.parentNode.appendChild(el);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Remove el from DOM
|
||
*
|
||
* @param {Element} el
|
||
*/
|
||
|
||
function remove(el) {
|
||
el.parentNode.removeChild(el);
|
||
}
|
||
|
||
/**
|
||
* Prepend el to target
|
||
*
|
||
* @param {Element} el
|
||
* @param {Element} target
|
||
*/
|
||
|
||
function prepend(el, target) {
|
||
if (target.firstChild) {
|
||
before(el, target.firstChild);
|
||
} else {
|
||
target.appendChild(el);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Replace target with el
|
||
*
|
||
* @param {Element} target
|
||
* @param {Element} el
|
||
*/
|
||
|
||
function replace(target, el) {
|
||
var parent = target.parentNode;
|
||
if (parent) {
|
||
parent.replaceChild(el, target);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Add event listener shorthand.
|
||
*
|
||
* @param {Element} el
|
||
* @param {String} event
|
||
* @param {Function} cb
|
||
* @param {Boolean} [useCapture]
|
||
*/
|
||
|
||
function on(el, event, cb, useCapture) {
|
||
el.addEventListener(event, cb, useCapture);
|
||
}
|
||
|
||
/**
|
||
* Remove event listener shorthand.
|
||
*
|
||
* @param {Element} el
|
||
* @param {String} event
|
||
* @param {Function} cb
|
||
*/
|
||
|
||
function off(el, event, cb) {
|
||
el.removeEventListener(event, cb);
|
||
}
|
||
|
||
/**
|
||
* In IE9, setAttribute('class') will result in empty class
|
||
* if the element also has the :class attribute; However in
|
||
* PhantomJS, setting `className` does not work on SVG elements...
|
||
* So we have to do a conditional check here.
|
||
*
|
||
* @param {Element} el
|
||
* @param {String} cls
|
||
*/
|
||
|
||
function setClass(el, cls) {
|
||
/* istanbul ignore if */
|
||
if (isIE9 && !/svg$/.test(el.namespaceURI)) {
|
||
el.className = cls;
|
||
} else {
|
||
el.setAttribute('class', cls);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Add class with compatibility for IE & SVG
|
||
*
|
||
* @param {Element} el
|
||
* @param {String} cls
|
||
*/
|
||
|
||
function addClass(el, cls) {
|
||
if (el.classList) {
|
||
el.classList.add(cls);
|
||
} else {
|
||
var cur = ' ' + (el.getAttribute('class') || '') + ' ';
|
||
if (cur.indexOf(' ' + cls + ' ') < 0) {
|
||
setClass(el, (cur + cls).trim());
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Remove class with compatibility for IE & SVG
|
||
*
|
||
* @param {Element} el
|
||
* @param {String} cls
|
||
*/
|
||
|
||
function removeClass(el, cls) {
|
||
if (el.classList) {
|
||
el.classList.remove(cls);
|
||
} else {
|
||
var cur = ' ' + (el.getAttribute('class') || '') + ' ';
|
||
var tar = ' ' + cls + ' ';
|
||
while (cur.indexOf(tar) >= 0) {
|
||
cur = cur.replace(tar, ' ');
|
||
}
|
||
setClass(el, cur.trim());
|
||
}
|
||
if (!el.className) {
|
||
el.removeAttribute('class');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Extract raw content inside an element into a temporary
|
||
* container div
|
||
*
|
||
* @param {Element} el
|
||
* @param {Boolean} asFragment
|
||
* @return {Element|DocumentFragment}
|
||
*/
|
||
|
||
function extractContent(el, asFragment) {
|
||
var child;
|
||
var rawContent;
|
||
/* istanbul ignore if */
|
||
if (isTemplate(el) && isFragment(el.content)) {
|
||
el = el.content;
|
||
}
|
||
if (el.hasChildNodes()) {
|
||
trimNode(el);
|
||
rawContent = asFragment ? document.createDocumentFragment() : document.createElement('div');
|
||
/* eslint-disable no-cond-assign */
|
||
while (child = el.firstChild) {
|
||
/* eslint-enable no-cond-assign */
|
||
rawContent.appendChild(child);
|
||
}
|
||
}
|
||
return rawContent;
|
||
}
|
||
|
||
/**
|
||
* Trim possible empty head/tail text and comment
|
||
* nodes inside a parent.
|
||
*
|
||
* @param {Node} node
|
||
*/
|
||
|
||
function trimNode(node) {
|
||
var child;
|
||
/* eslint-disable no-sequences */
|
||
while ((child = node.firstChild, isTrimmable(child))) {
|
||
node.removeChild(child);
|
||
}
|
||
while ((child = node.lastChild, isTrimmable(child))) {
|
||
node.removeChild(child);
|
||
}
|
||
/* eslint-enable no-sequences */
|
||
}
|
||
|
||
function isTrimmable(node) {
|
||
return node && (node.nodeType === 3 && !node.data.trim() || node.nodeType === 8);
|
||
}
|
||
|
||
/**
|
||
* Check if an element is a template tag.
|
||
* Note if the template appears inside an SVG its tagName
|
||
* will be in lowercase.
|
||
*
|
||
* @param {Element} el
|
||
*/
|
||
|
||
function isTemplate(el) {
|
||
return el.tagName && el.tagName.toLowerCase() === 'template';
|
||
}
|
||
|
||
/**
|
||
* Create an "anchor" for performing dom insertion/removals.
|
||
* This is used in a number of scenarios:
|
||
* - fragment instance
|
||
* - v-html
|
||
* - v-if
|
||
* - v-for
|
||
* - component
|
||
*
|
||
* @param {String} content
|
||
* @param {Boolean} persist - IE trashes empty textNodes on
|
||
* cloneNode(true), so in certain
|
||
* cases the anchor needs to be
|
||
* non-empty to be persisted in
|
||
* templates.
|
||
* @return {Comment|Text}
|
||
*/
|
||
|
||
function createAnchor(content, persist) {
|
||
var anchor = config.debug ? document.createComment(content) : document.createTextNode(persist ? ' ' : '');
|
||
anchor.__v_anchor = true;
|
||
return anchor;
|
||
}
|
||
|
||
/**
|
||
* Find a component ref attribute that starts with $.
|
||
*
|
||
* @param {Element} node
|
||
* @return {String|undefined}
|
||
*/
|
||
|
||
var refRE = /^v-ref:/;
|
||
|
||
function findRef(node) {
|
||
if (node.hasAttributes()) {
|
||
var attrs = node.attributes;
|
||
for (var i = 0, l = attrs.length; i < l; i++) {
|
||
var name = attrs[i].name;
|
||
if (refRE.test(name)) {
|
||
return camelize(name.replace(refRE, ''));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Map a function to a range of nodes .
|
||
*
|
||
* @param {Node} node
|
||
* @param {Node} end
|
||
* @param {Function} op
|
||
*/
|
||
|
||
function mapNodeRange(node, end, op) {
|
||
var next;
|
||
while (node !== end) {
|
||
next = node.nextSibling;
|
||
op(node);
|
||
node = next;
|
||
}
|
||
op(end);
|
||
}
|
||
|
||
/**
|
||
* Remove a range of nodes with transition, store
|
||
* the nodes in a fragment with correct ordering,
|
||
* and call callback when done.
|
||
*
|
||
* @param {Node} start
|
||
* @param {Node} end
|
||
* @param {Vue} vm
|
||
* @param {DocumentFragment} frag
|
||
* @param {Function} cb
|
||
*/
|
||
|
||
function removeNodeRange(start, end, vm, frag, cb) {
|
||
var done = false;
|
||
var removed = 0;
|
||
var nodes = [];
|
||
mapNodeRange(start, end, function (node) {
|
||
if (node === end) done = true;
|
||
nodes.push(node);
|
||
removeWithTransition(node, vm, onRemoved);
|
||
});
|
||
function onRemoved() {
|
||
removed++;
|
||
if (done && removed >= nodes.length) {
|
||
for (var i = 0; i < nodes.length; i++) {
|
||
frag.appendChild(nodes[i]);
|
||
}
|
||
cb && cb();
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Check if a node is a DocumentFragment.
|
||
*
|
||
* @param {Node} node
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
function isFragment(node) {
|
||
return node && node.nodeType === 11;
|
||
}
|
||
|
||
/**
|
||
* Get outerHTML of elements, taking care
|
||
* of SVG elements in IE as well.
|
||
*
|
||
* @param {Element} el
|
||
* @return {String}
|
||
*/
|
||
|
||
function getOuterHTML(el) {
|
||
if (el.outerHTML) {
|
||
return el.outerHTML;
|
||
} else {
|
||
var container = document.createElement('div');
|
||
container.appendChild(el.cloneNode(true));
|
||
return container.innerHTML;
|
||
}
|
||
}
|
||
|
||
var commonTagRE = /^(div|p|span|img|a|b|i|br|ul|ol|li|h1|h2|h3|h4|h5|h6|code|pre|table|th|td|tr|form|label|input|select|option|nav|article|section|header|footer)$/;
|
||
var reservedTagRE = /^(slot|partial|component)$/;
|
||
|
||
var isUnknownElement = undefined;
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
isUnknownElement = function (el, tag) {
|
||
if (tag.indexOf('-') > -1) {
|
||
// http://stackoverflow.com/a/28210364/1070244
|
||
return el.constructor === window.HTMLUnknownElement || el.constructor === window.HTMLElement;
|
||
} else {
|
||
return (/HTMLUnknownElement/.test(el.toString()) &&
|
||
// Chrome returns unknown for several HTML5 elements.
|
||
// https://code.google.com/p/chromium/issues/detail?id=540526
|
||
!/^(data|time|rtc|rb)$/.test(tag)
|
||
);
|
||
}
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Check if an element is a component, if yes return its
|
||
* component id.
|
||
*
|
||
* @param {Element} el
|
||
* @param {Object} options
|
||
* @return {Object|undefined}
|
||
*/
|
||
|
||
function checkComponentAttr(el, options) {
|
||
var tag = el.tagName.toLowerCase();
|
||
var hasAttrs = el.hasAttributes();
|
||
if (!commonTagRE.test(tag) && !reservedTagRE.test(tag)) {
|
||
if (resolveAsset(options, 'components', tag)) {
|
||
return { id: tag };
|
||
} else {
|
||
var is = hasAttrs && getIsBinding(el);
|
||
if (is) {
|
||
return is;
|
||
} else if (process.env.NODE_ENV !== 'production') {
|
||
var expectedTag = options._componentNameMap && options._componentNameMap[tag];
|
||
if (expectedTag) {
|
||
warn('Unknown custom element: <' + tag + '> - ' + 'did you mean <' + expectedTag + '>? ' + 'HTML is case-insensitive, remember to use kebab-case in templates.');
|
||
} else if (isUnknownElement(el, tag)) {
|
||
warn('Unknown custom element: <' + tag + '> - did you ' + 'register the component correctly? For recursive components, ' + 'make sure to provide the "name" option.');
|
||
}
|
||
}
|
||
}
|
||
} else if (hasAttrs) {
|
||
return getIsBinding(el);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Get "is" binding from an element.
|
||
*
|
||
* @param {Element} el
|
||
* @return {Object|undefined}
|
||
*/
|
||
|
||
function getIsBinding(el) {
|
||
// dynamic syntax
|
||
var exp = getAttr(el, 'is');
|
||
if (exp != null) {
|
||
return { id: exp };
|
||
} else {
|
||
exp = getBindAttr(el, 'is');
|
||
if (exp != null) {
|
||
return { id: exp, dynamic: true };
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Set a prop's initial value on a vm and its data object.
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {Object} prop
|
||
* @param {*} value
|
||
*/
|
||
|
||
function initProp(vm, prop, value) {
|
||
var key = prop.path;
|
||
value = coerceProp(prop, value);
|
||
vm[key] = vm._data[key] = assertProp(prop, value) ? value : undefined;
|
||
}
|
||
|
||
/**
|
||
* Assert whether a prop is valid.
|
||
*
|
||
* @param {Object} prop
|
||
* @param {*} value
|
||
*/
|
||
|
||
function assertProp(prop, value) {
|
||
if (!prop.options.required && ( // non-required
|
||
prop.raw === null || // abscent
|
||
value == null) // null or undefined
|
||
) {
|
||
return true;
|
||
}
|
||
var options = prop.options;
|
||
var type = options.type;
|
||
var valid = true;
|
||
var expectedType;
|
||
if (type) {
|
||
if (type === String) {
|
||
expectedType = 'string';
|
||
valid = typeof value === expectedType;
|
||
} else if (type === Number) {
|
||
expectedType = 'number';
|
||
valid = typeof value === 'number';
|
||
} else if (type === Boolean) {
|
||
expectedType = 'boolean';
|
||
valid = typeof value === 'boolean';
|
||
} else if (type === Function) {
|
||
expectedType = 'function';
|
||
valid = typeof value === 'function';
|
||
} else if (type === Object) {
|
||
expectedType = 'object';
|
||
valid = isPlainObject(value);
|
||
} else if (type === Array) {
|
||
expectedType = 'array';
|
||
valid = isArray(value);
|
||
} else {
|
||
valid = value instanceof type;
|
||
}
|
||
}
|
||
if (!valid) {
|
||
process.env.NODE_ENV !== 'production' && warn('Invalid prop: type check failed for ' + prop.path + '="' + prop.raw + '".' + ' Expected ' + formatType(expectedType) + ', got ' + formatValue(value) + '.');
|
||
return false;
|
||
}
|
||
var validator = options.validator;
|
||
if (validator) {
|
||
if (!validator(value)) {
|
||
process.env.NODE_ENV !== 'production' && warn('Invalid prop: custom validator check failed for ' + prop.path + '="' + prop.raw + '"');
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* Force parsing value with coerce option.
|
||
*
|
||
* @param {*} value
|
||
* @param {Object} options
|
||
* @return {*}
|
||
*/
|
||
|
||
function coerceProp(prop, value) {
|
||
var coerce = prop.options.coerce;
|
||
if (!coerce) {
|
||
return value;
|
||
}
|
||
// coerce is a function
|
||
return coerce(value);
|
||
}
|
||
|
||
function formatType(val) {
|
||
return val ? val.charAt(0).toUpperCase() + val.slice(1) : 'custom type';
|
||
}
|
||
|
||
function formatValue(val) {
|
||
return Object.prototype.toString.call(val).slice(8, -1);
|
||
}
|
||
|
||
/**
|
||
* Option overwriting strategies are functions that handle
|
||
* how to merge a parent option value and a child option
|
||
* value into the final value.
|
||
*
|
||
* All strategy functions follow the same signature:
|
||
*
|
||
* @param {*} parentVal
|
||
* @param {*} childVal
|
||
* @param {Vue} [vm]
|
||
*/
|
||
|
||
var strats = config.optionMergeStrategies = Object.create(null);
|
||
|
||
/**
|
||
* Helper that recursively merges two data objects together.
|
||
*/
|
||
|
||
function mergeData(to, from) {
|
||
var key, toVal, fromVal;
|
||
for (key in from) {
|
||
toVal = to[key];
|
||
fromVal = from[key];
|
||
if (!hasOwn(to, key)) {
|
||
set(to, key, fromVal);
|
||
} else if (isObject(toVal) && isObject(fromVal)) {
|
||
mergeData(toVal, fromVal);
|
||
}
|
||
}
|
||
return to;
|
||
}
|
||
|
||
/**
|
||
* Data
|
||
*/
|
||
|
||
strats.data = function (parentVal, childVal, vm) {
|
||
if (!vm) {
|
||
// in a Vue.extend merge, both should be functions
|
||
if (!childVal) {
|
||
return parentVal;
|
||
}
|
||
if (typeof childVal !== 'function') {
|
||
process.env.NODE_ENV !== 'production' && warn('The "data" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.');
|
||
return parentVal;
|
||
}
|
||
if (!parentVal) {
|
||
return childVal;
|
||
}
|
||
// when parentVal & childVal are both present,
|
||
// we need to return a function that returns the
|
||
// merged result of both functions... no need to
|
||
// check if parentVal is a function here because
|
||
// it has to be a function to pass previous merges.
|
||
return function mergedDataFn() {
|
||
return mergeData(childVal.call(this), parentVal.call(this));
|
||
};
|
||
} else if (parentVal || childVal) {
|
||
return function mergedInstanceDataFn() {
|
||
// instance merge
|
||
var instanceData = typeof childVal === 'function' ? childVal.call(vm) : childVal;
|
||
var defaultData = typeof parentVal === 'function' ? parentVal.call(vm) : undefined;
|
||
if (instanceData) {
|
||
return mergeData(instanceData, defaultData);
|
||
} else {
|
||
return defaultData;
|
||
}
|
||
};
|
||
}
|
||
};
|
||
|
||
/**
|
||
* El
|
||
*/
|
||
|
||
strats.el = function (parentVal, childVal, vm) {
|
||
if (!vm && childVal && typeof childVal !== 'function') {
|
||
process.env.NODE_ENV !== 'production' && warn('The "el" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.');
|
||
return;
|
||
}
|
||
var ret = childVal || parentVal;
|
||
// invoke the element factory if this is instance merge
|
||
return vm && typeof ret === 'function' ? ret.call(vm) : ret;
|
||
};
|
||
|
||
/**
|
||
* Hooks and param attributes are merged as arrays.
|
||
*/
|
||
|
||
strats.init = strats.created = strats.ready = strats.attached = strats.detached = strats.beforeCompile = strats.compiled = strats.beforeDestroy = strats.destroyed = strats.activate = function (parentVal, childVal) {
|
||
return childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal;
|
||
};
|
||
|
||
/**
|
||
* 0.11 deprecation warning
|
||
*/
|
||
|
||
strats.paramAttributes = function () {
|
||
/* istanbul ignore next */
|
||
process.env.NODE_ENV !== 'production' && warn('"paramAttributes" option has been deprecated in 0.12. ' + 'Use "props" instead.');
|
||
};
|
||
|
||
/**
|
||
* Assets
|
||
*
|
||
* When a vm is present (instance creation), we need to do
|
||
* a three-way merge between constructor options, instance
|
||
* options and parent options.
|
||
*/
|
||
|
||
function mergeAssets(parentVal, childVal) {
|
||
var res = Object.create(parentVal);
|
||
return childVal ? extend(res, guardArrayAssets(childVal)) : res;
|
||
}
|
||
|
||
config._assetTypes.forEach(function (type) {
|
||
strats[type + 's'] = mergeAssets;
|
||
});
|
||
|
||
/**
|
||
* Events & Watchers.
|
||
*
|
||
* Events & watchers hashes should not overwrite one
|
||
* another, so we merge them as arrays.
|
||
*/
|
||
|
||
strats.watch = strats.events = function (parentVal, childVal) {
|
||
if (!childVal) return parentVal;
|
||
if (!parentVal) return childVal;
|
||
var ret = {};
|
||
extend(ret, parentVal);
|
||
for (var key in childVal) {
|
||
var parent = ret[key];
|
||
var child = childVal[key];
|
||
if (parent && !isArray(parent)) {
|
||
parent = [parent];
|
||
}
|
||
ret[key] = parent ? parent.concat(child) : [child];
|
||
}
|
||
return ret;
|
||
};
|
||
|
||
/**
|
||
* Other object hashes.
|
||
*/
|
||
|
||
strats.props = strats.methods = strats.computed = function (parentVal, childVal) {
|
||
if (!childVal) return parentVal;
|
||
if (!parentVal) return childVal;
|
||
var ret = Object.create(null);
|
||
extend(ret, parentVal);
|
||
extend(ret, childVal);
|
||
return ret;
|
||
};
|
||
|
||
/**
|
||
* Default strategy.
|
||
*/
|
||
|
||
var defaultStrat = function defaultStrat(parentVal, childVal) {
|
||
return childVal === undefined ? parentVal : childVal;
|
||
};
|
||
|
||
/**
|
||
* Make sure component options get converted to actual
|
||
* constructors.
|
||
*
|
||
* @param {Object} options
|
||
*/
|
||
|
||
function guardComponents(options) {
|
||
if (options.components) {
|
||
var components = options.components = guardArrayAssets(options.components);
|
||
var ids = Object.keys(components);
|
||
var def;
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
var map = options._componentNameMap = {};
|
||
}
|
||
for (var i = 0, l = ids.length; i < l; i++) {
|
||
var key = ids[i];
|
||
if (commonTagRE.test(key) || reservedTagRE.test(key)) {
|
||
process.env.NODE_ENV !== 'production' && warn('Do not use built-in or reserved HTML elements as component ' + 'id: ' + key);
|
||
continue;
|
||
}
|
||
// record a all lowercase <-> kebab-case mapping for
|
||
// possible custom element case error warning
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
map[key.replace(/-/g, '').toLowerCase()] = hyphenate(key);
|
||
}
|
||
def = components[key];
|
||
if (isPlainObject(def)) {
|
||
components[key] = Vue.extend(def);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Ensure all props option syntax are normalized into the
|
||
* Object-based format.
|
||
*
|
||
* @param {Object} options
|
||
*/
|
||
|
||
function guardProps(options) {
|
||
var props = options.props;
|
||
var i, val;
|
||
if (isArray(props)) {
|
||
options.props = {};
|
||
i = props.length;
|
||
while (i--) {
|
||
val = props[i];
|
||
if (typeof val === 'string') {
|
||
options.props[val] = null;
|
||
} else if (val.name) {
|
||
options.props[val.name] = val;
|
||
}
|
||
}
|
||
} else if (isPlainObject(props)) {
|
||
var keys = Object.keys(props);
|
||
i = keys.length;
|
||
while (i--) {
|
||
val = props[keys[i]];
|
||
if (typeof val === 'function') {
|
||
props[keys[i]] = { type: val };
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Guard an Array-format assets option and converted it
|
||
* into the key-value Object format.
|
||
*
|
||
* @param {Object|Array} assets
|
||
* @return {Object}
|
||
*/
|
||
|
||
function guardArrayAssets(assets) {
|
||
if (isArray(assets)) {
|
||
var res = {};
|
||
var i = assets.length;
|
||
var asset;
|
||
while (i--) {
|
||
asset = assets[i];
|
||
var id = typeof asset === 'function' ? asset.options && asset.options.name || asset.id : asset.name || asset.id;
|
||
if (!id) {
|
||
process.env.NODE_ENV !== 'production' && warn('Array-syntax assets must provide a "name" or "id" field.');
|
||
} else {
|
||
res[id] = asset;
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
return assets;
|
||
}
|
||
|
||
/**
|
||
* Merge two option objects into a new one.
|
||
* Core utility used in both instantiation and inheritance.
|
||
*
|
||
* @param {Object} parent
|
||
* @param {Object} child
|
||
* @param {Vue} [vm] - if vm is present, indicates this is
|
||
* an instantiation merge.
|
||
*/
|
||
|
||
function mergeOptions(parent, child, vm) {
|
||
guardComponents(child);
|
||
guardProps(child);
|
||
var options = {};
|
||
var key;
|
||
if (child.mixins) {
|
||
for (var i = 0, l = child.mixins.length; i < l; i++) {
|
||
parent = mergeOptions(parent, child.mixins[i], vm);
|
||
}
|
||
}
|
||
for (key in parent) {
|
||
mergeField(key);
|
||
}
|
||
for (key in child) {
|
||
if (!hasOwn(parent, key)) {
|
||
mergeField(key);
|
||
}
|
||
}
|
||
function mergeField(key) {
|
||
var strat = strats[key] || defaultStrat;
|
||
options[key] = strat(parent[key], child[key], vm, key);
|
||
}
|
||
return options;
|
||
}
|
||
|
||
/**
|
||
* Resolve an asset.
|
||
* This function is used because child instances need access
|
||
* to assets defined in its ancestor chain.
|
||
*
|
||
* @param {Object} options
|
||
* @param {String} type
|
||
* @param {String} id
|
||
* @return {Object|Function}
|
||
*/
|
||
|
||
function resolveAsset(options, type, id) {
|
||
/* istanbul ignore if */
|
||
if (typeof id !== 'string') {
|
||
return;
|
||
}
|
||
var assets = options[type];
|
||
var camelizedId;
|
||
return assets[id] ||
|
||
// camelCase ID
|
||
assets[camelizedId = camelize(id)] ||
|
||
// Pascal Case ID
|
||
assets[camelizedId.charAt(0).toUpperCase() + camelizedId.slice(1)];
|
||
}
|
||
|
||
/**
|
||
* Assert asset exists
|
||
*/
|
||
|
||
function assertAsset(val, type, id) {
|
||
if (!val) {
|
||
process.env.NODE_ENV !== 'production' && warn('Failed to resolve ' + type + ': ' + id);
|
||
}
|
||
}
|
||
|
||
var uid$1 = 0;
|
||
|
||
/**
|
||
* A dep is an observable that can have multiple
|
||
* directives subscribing to it.
|
||
*
|
||
* @constructor
|
||
*/
|
||
function Dep() {
|
||
this.id = uid$1++;
|
||
this.subs = [];
|
||
}
|
||
|
||
// the current target watcher being evaluated.
|
||
// this is globally unique because there could be only one
|
||
// watcher being evaluated at any time.
|
||
Dep.target = null;
|
||
|
||
/**
|
||
* Add a directive subscriber.
|
||
*
|
||
* @param {Directive} sub
|
||
*/
|
||
|
||
Dep.prototype.addSub = function (sub) {
|
||
this.subs.push(sub);
|
||
};
|
||
|
||
/**
|
||
* Remove a directive subscriber.
|
||
*
|
||
* @param {Directive} sub
|
||
*/
|
||
|
||
Dep.prototype.removeSub = function (sub) {
|
||
this.subs.$remove(sub);
|
||
};
|
||
|
||
/**
|
||
* Add self as a dependency to the target watcher.
|
||
*/
|
||
|
||
Dep.prototype.depend = function () {
|
||
Dep.target.addDep(this);
|
||
};
|
||
|
||
/**
|
||
* Notify all subscribers of a new value.
|
||
*/
|
||
|
||
Dep.prototype.notify = function () {
|
||
// stablize the subscriber list first
|
||
var subs = toArray(this.subs);
|
||
for (var i = 0, l = subs.length; i < l; i++) {
|
||
subs[i].update();
|
||
}
|
||
};
|
||
|
||
var arrayProto = Array.prototype;
|
||
var arrayMethods = Object.create(arrayProto)
|
||
|
||
/**
|
||
* Intercept mutating methods and emit events
|
||
*/
|
||
|
||
;['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'].forEach(function (method) {
|
||
// cache original method
|
||
var original = arrayProto[method];
|
||
def(arrayMethods, method, function mutator() {
|
||
// avoid leaking arguments:
|
||
// http://jsperf.com/closure-with-arguments
|
||
var i = arguments.length;
|
||
var args = new Array(i);
|
||
while (i--) {
|
||
args[i] = arguments[i];
|
||
}
|
||
var result = original.apply(this, args);
|
||
var ob = this.__ob__;
|
||
var inserted;
|
||
switch (method) {
|
||
case 'push':
|
||
inserted = args;
|
||
break;
|
||
case 'unshift':
|
||
inserted = args;
|
||
break;
|
||
case 'splice':
|
||
inserted = args.slice(2);
|
||
break;
|
||
}
|
||
if (inserted) ob.observeArray(inserted);
|
||
// notify change
|
||
ob.dep.notify();
|
||
return result;
|
||
});
|
||
});
|
||
|
||
/**
|
||
* Swap the element at the given index with a new value
|
||
* and emits corresponding event.
|
||
*
|
||
* @param {Number} index
|
||
* @param {*} val
|
||
* @return {*} - replaced element
|
||
*/
|
||
|
||
def(arrayProto, '$set', function $set(index, val) {
|
||
if (index >= this.length) {
|
||
this.length = Number(index) + 1;
|
||
}
|
||
return this.splice(index, 1, val)[0];
|
||
});
|
||
|
||
/**
|
||
* Convenience method to remove the element at given index.
|
||
*
|
||
* @param {Number} index
|
||
* @param {*} val
|
||
*/
|
||
|
||
def(arrayProto, '$remove', function $remove(item) {
|
||
/* istanbul ignore if */
|
||
if (!this.length) return;
|
||
var index = indexOf(this, item);
|
||
if (index > -1) {
|
||
return this.splice(index, 1);
|
||
}
|
||
});
|
||
|
||
var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
|
||
|
||
/**
|
||
* Observer class that are attached to each observed
|
||
* object. Once attached, the observer converts target
|
||
* object's property keys into getter/setters that
|
||
* collect dependencies and dispatches updates.
|
||
*
|
||
* @param {Array|Object} value
|
||
* @constructor
|
||
*/
|
||
|
||
function Observer(value) {
|
||
this.value = value;
|
||
this.dep = new Dep();
|
||
def(value, '__ob__', this);
|
||
if (isArray(value)) {
|
||
var augment = hasProto ? protoAugment : copyAugment;
|
||
augment(value, arrayMethods, arrayKeys);
|
||
this.observeArray(value);
|
||
} else {
|
||
this.walk(value);
|
||
}
|
||
}
|
||
|
||
// Instance methods
|
||
|
||
/**
|
||
* Walk through each property and convert them into
|
||
* getter/setters. This method should only be called when
|
||
* value type is Object.
|
||
*
|
||
* @param {Object} obj
|
||
*/
|
||
|
||
Observer.prototype.walk = function (obj) {
|
||
var keys = Object.keys(obj);
|
||
for (var i = 0, l = keys.length; i < l; i++) {
|
||
this.convert(keys[i], obj[keys[i]]);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Observe a list of Array items.
|
||
*
|
||
* @param {Array} items
|
||
*/
|
||
|
||
Observer.prototype.observeArray = function (items) {
|
||
for (var i = 0, l = items.length; i < l; i++) {
|
||
observe(items[i]);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Convert a property into getter/setter so we can emit
|
||
* the events when the property is accessed/changed.
|
||
*
|
||
* @param {String} key
|
||
* @param {*} val
|
||
*/
|
||
|
||
Observer.prototype.convert = function (key, val) {
|
||
defineReactive(this.value, key, val);
|
||
};
|
||
|
||
/**
|
||
* Add an owner vm, so that when $set/$delete mutations
|
||
* happen we can notify owner vms to proxy the keys and
|
||
* digest the watchers. This is only called when the object
|
||
* is observed as an instance's root $data.
|
||
*
|
||
* @param {Vue} vm
|
||
*/
|
||
|
||
Observer.prototype.addVm = function (vm) {
|
||
(this.vms || (this.vms = [])).push(vm);
|
||
};
|
||
|
||
/**
|
||
* Remove an owner vm. This is called when the object is
|
||
* swapped out as an instance's $data object.
|
||
*
|
||
* @param {Vue} vm
|
||
*/
|
||
|
||
Observer.prototype.removeVm = function (vm) {
|
||
this.vms.$remove(vm);
|
||
};
|
||
|
||
// helpers
|
||
|
||
/**
|
||
* Augment an target Object or Array by intercepting
|
||
* the prototype chain using __proto__
|
||
*
|
||
* @param {Object|Array} target
|
||
* @param {Object} proto
|
||
*/
|
||
|
||
function protoAugment(target, src) {
|
||
/* eslint-disable no-proto */
|
||
target.__proto__ = src;
|
||
/* eslint-enable no-proto */
|
||
}
|
||
|
||
/**
|
||
* Augment an target Object or Array by defining
|
||
* hidden properties.
|
||
*
|
||
* @param {Object|Array} target
|
||
* @param {Object} proto
|
||
*/
|
||
|
||
function copyAugment(target, src, keys) {
|
||
for (var i = 0, l = keys.length; i < l; i++) {
|
||
var key = keys[i];
|
||
def(target, key, src[key]);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Attempt to create an observer instance for a value,
|
||
* returns the new observer if successfully observed,
|
||
* or the existing observer if the value already has one.
|
||
*
|
||
* @param {*} value
|
||
* @param {Vue} [vm]
|
||
* @return {Observer|undefined}
|
||
* @static
|
||
*/
|
||
|
||
function observe(value, vm) {
|
||
if (!value || typeof value !== 'object') {
|
||
return;
|
||
}
|
||
var ob;
|
||
if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
|
||
ob = value.__ob__;
|
||
} else if ((isArray(value) || isPlainObject(value)) && Object.isExtensible(value) && !value._isVue) {
|
||
ob = new Observer(value);
|
||
}
|
||
if (ob && vm) {
|
||
ob.addVm(vm);
|
||
}
|
||
return ob;
|
||
}
|
||
|
||
/**
|
||
* Define a reactive property on an Object.
|
||
*
|
||
* @param {Object} obj
|
||
* @param {String} key
|
||
* @param {*} val
|
||
*/
|
||
|
||
function defineReactive(obj, key, val) {
|
||
var dep = new Dep();
|
||
|
||
var property = Object.getOwnPropertyDescriptor(obj, key);
|
||
if (property && property.configurable === false) {
|
||
return;
|
||
}
|
||
|
||
// cater for pre-defined getter/setters
|
||
var getter = property && property.get;
|
||
var setter = property && property.set;
|
||
|
||
var childOb = observe(val);
|
||
Object.defineProperty(obj, key, {
|
||
enumerable: true,
|
||
configurable: true,
|
||
get: function reactiveGetter() {
|
||
var value = getter ? getter.call(obj) : val;
|
||
if (Dep.target) {
|
||
dep.depend();
|
||
if (childOb) {
|
||
childOb.dep.depend();
|
||
}
|
||
if (isArray(value)) {
|
||
for (var e, i = 0, l = value.length; i < l; i++) {
|
||
e = value[i];
|
||
e && e.__ob__ && e.__ob__.dep.depend();
|
||
}
|
||
}
|
||
}
|
||
return value;
|
||
},
|
||
set: function reactiveSetter(newVal) {
|
||
var value = getter ? getter.call(obj) : val;
|
||
if (newVal === value) {
|
||
return;
|
||
}
|
||
if (setter) {
|
||
setter.call(obj, newVal);
|
||
} else {
|
||
val = newVal;
|
||
}
|
||
childOb = observe(newVal);
|
||
dep.notify();
|
||
}
|
||
});
|
||
}
|
||
|
||
|
||
|
||
var util = Object.freeze({
|
||
defineReactive: defineReactive,
|
||
set: set,
|
||
del: del,
|
||
hasOwn: hasOwn,
|
||
isLiteral: isLiteral,
|
||
isReserved: isReserved,
|
||
_toString: _toString,
|
||
toNumber: toNumber,
|
||
toBoolean: toBoolean,
|
||
stripQuotes: stripQuotes,
|
||
camelize: camelize,
|
||
hyphenate: hyphenate,
|
||
classify: classify,
|
||
bind: bind,
|
||
toArray: toArray,
|
||
extend: extend,
|
||
isObject: isObject,
|
||
isPlainObject: isPlainObject,
|
||
def: def,
|
||
debounce: _debounce,
|
||
indexOf: indexOf,
|
||
cancellable: cancellable,
|
||
looseEqual: looseEqual,
|
||
isArray: isArray,
|
||
hasProto: hasProto,
|
||
inBrowser: inBrowser,
|
||
devtools: devtools,
|
||
isIE9: isIE9,
|
||
isAndroid: isAndroid,
|
||
get transitionProp () { return transitionProp; },
|
||
get transitionEndEvent () { return transitionEndEvent; },
|
||
get animationProp () { return animationProp; },
|
||
get animationEndEvent () { return animationEndEvent; },
|
||
nextTick: nextTick,
|
||
query: query,
|
||
inDoc: inDoc,
|
||
getAttr: getAttr,
|
||
getBindAttr: getBindAttr,
|
||
hasBindAttr: hasBindAttr,
|
||
before: before,
|
||
after: after,
|
||
remove: remove,
|
||
prepend: prepend,
|
||
replace: replace,
|
||
on: on,
|
||
off: off,
|
||
setClass: setClass,
|
||
addClass: addClass,
|
||
removeClass: removeClass,
|
||
extractContent: extractContent,
|
||
trimNode: trimNode,
|
||
isTemplate: isTemplate,
|
||
createAnchor: createAnchor,
|
||
findRef: findRef,
|
||
mapNodeRange: mapNodeRange,
|
||
removeNodeRange: removeNodeRange,
|
||
isFragment: isFragment,
|
||
getOuterHTML: getOuterHTML,
|
||
mergeOptions: mergeOptions,
|
||
resolveAsset: resolveAsset,
|
||
assertAsset: assertAsset,
|
||
checkComponentAttr: checkComponentAttr,
|
||
initProp: initProp,
|
||
assertProp: assertProp,
|
||
coerceProp: coerceProp,
|
||
commonTagRE: commonTagRE,
|
||
reservedTagRE: reservedTagRE,
|
||
get warn () { return warn; }
|
||
});
|
||
|
||
var uid = 0;
|
||
|
||
function initMixin (Vue) {
|
||
/**
|
||
* The main init sequence. This is called for every
|
||
* instance, including ones that are created from extended
|
||
* constructors.
|
||
*
|
||
* @param {Object} options - this options object should be
|
||
* the result of merging class
|
||
* options and the options passed
|
||
* in to the constructor.
|
||
*/
|
||
|
||
Vue.prototype._init = function (options) {
|
||
options = options || {};
|
||
|
||
this.$el = null;
|
||
this.$parent = options.parent;
|
||
this.$root = this.$parent ? this.$parent.$root : this;
|
||
this.$children = [];
|
||
this.$refs = {}; // child vm references
|
||
this.$els = {}; // element references
|
||
this._watchers = []; // all watchers as an array
|
||
this._directives = []; // all directives
|
||
|
||
// a uid
|
||
this._uid = uid++;
|
||
|
||
// a flag to avoid this being observed
|
||
this._isVue = true;
|
||
|
||
// events bookkeeping
|
||
this._events = {}; // registered callbacks
|
||
this._eventsCount = {}; // for $broadcast optimization
|
||
|
||
// fragment instance properties
|
||
this._isFragment = false;
|
||
this._fragment = // @type {DocumentFragment}
|
||
this._fragmentStart = // @type {Text|Comment}
|
||
this._fragmentEnd = null; // @type {Text|Comment}
|
||
|
||
// lifecycle state
|
||
this._isCompiled = this._isDestroyed = this._isReady = this._isAttached = this._isBeingDestroyed = this._vForRemoving = false;
|
||
this._unlinkFn = null;
|
||
|
||
// context:
|
||
// if this is a transcluded component, context
|
||
// will be the common parent vm of this instance
|
||
// and its host.
|
||
this._context = options._context || this.$parent;
|
||
|
||
// scope:
|
||
// if this is inside an inline v-for, the scope
|
||
// will be the intermediate scope created for this
|
||
// repeat fragment. this is used for linking props
|
||
// and container directives.
|
||
this._scope = options._scope;
|
||
|
||
// fragment:
|
||
// if this instance is compiled inside a Fragment, it
|
||
// needs to reigster itself as a child of that fragment
|
||
// for attach/detach to work properly.
|
||
this._frag = options._frag;
|
||
if (this._frag) {
|
||
this._frag.children.push(this);
|
||
}
|
||
|
||
// push self into parent / transclusion host
|
||
if (this.$parent) {
|
||
this.$parent.$children.push(this);
|
||
}
|
||
|
||
// save raw constructor data before merge
|
||
// so that we know which properties are provided at
|
||
// instantiation.
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
this._runtimeData = options.data;
|
||
}
|
||
|
||
// merge options.
|
||
options = this.$options = mergeOptions(this.constructor.options, options, this);
|
||
|
||
// set ref
|
||
this._updateRef();
|
||
|
||
// initialize data as empty object.
|
||
// it will be filled up in _initScope().
|
||
this._data = {};
|
||
|
||
// call init hook
|
||
this._callHook('init');
|
||
|
||
// initialize data observation and scope inheritance.
|
||
this._initState();
|
||
|
||
// setup event system and option events.
|
||
this._initEvents();
|
||
|
||
// call created hook
|
||
this._callHook('created');
|
||
|
||
// if `el` option is passed, start compilation.
|
||
if (options.el) {
|
||
this.$mount(options.el);
|
||
}
|
||
};
|
||
}
|
||
|
||
var pathCache = new Cache(1000);
|
||
|
||
// actions
|
||
var APPEND = 0;
|
||
var PUSH = 1;
|
||
var INC_SUB_PATH_DEPTH = 2;
|
||
var PUSH_SUB_PATH = 3;
|
||
|
||
// states
|
||
var BEFORE_PATH = 0;
|
||
var IN_PATH = 1;
|
||
var BEFORE_IDENT = 2;
|
||
var IN_IDENT = 3;
|
||
var IN_SUB_PATH = 4;
|
||
var IN_SINGLE_QUOTE = 5;
|
||
var IN_DOUBLE_QUOTE = 6;
|
||
var AFTER_PATH = 7;
|
||
var ERROR = 8;
|
||
|
||
var pathStateMachine = [];
|
||
|
||
pathStateMachine[BEFORE_PATH] = {
|
||
'ws': [BEFORE_PATH],
|
||
'ident': [IN_IDENT, APPEND],
|
||
'[': [IN_SUB_PATH],
|
||
'eof': [AFTER_PATH]
|
||
};
|
||
|
||
pathStateMachine[IN_PATH] = {
|
||
'ws': [IN_PATH],
|
||
'.': [BEFORE_IDENT],
|
||
'[': [IN_SUB_PATH],
|
||
'eof': [AFTER_PATH]
|
||
};
|
||
|
||
pathStateMachine[BEFORE_IDENT] = {
|
||
'ws': [BEFORE_IDENT],
|
||
'ident': [IN_IDENT, APPEND]
|
||
};
|
||
|
||
pathStateMachine[IN_IDENT] = {
|
||
'ident': [IN_IDENT, APPEND],
|
||
'0': [IN_IDENT, APPEND],
|
||
'number': [IN_IDENT, APPEND],
|
||
'ws': [IN_PATH, PUSH],
|
||
'.': [BEFORE_IDENT, PUSH],
|
||
'[': [IN_SUB_PATH, PUSH],
|
||
'eof': [AFTER_PATH, PUSH]
|
||
};
|
||
|
||
pathStateMachine[IN_SUB_PATH] = {
|
||
"'": [IN_SINGLE_QUOTE, APPEND],
|
||
'"': [IN_DOUBLE_QUOTE, APPEND],
|
||
'[': [IN_SUB_PATH, INC_SUB_PATH_DEPTH],
|
||
']': [IN_PATH, PUSH_SUB_PATH],
|
||
'eof': ERROR,
|
||
'else': [IN_SUB_PATH, APPEND]
|
||
};
|
||
|
||
pathStateMachine[IN_SINGLE_QUOTE] = {
|
||
"'": [IN_SUB_PATH, APPEND],
|
||
'eof': ERROR,
|
||
'else': [IN_SINGLE_QUOTE, APPEND]
|
||
};
|
||
|
||
pathStateMachine[IN_DOUBLE_QUOTE] = {
|
||
'"': [IN_SUB_PATH, APPEND],
|
||
'eof': ERROR,
|
||
'else': [IN_DOUBLE_QUOTE, APPEND]
|
||
};
|
||
|
||
/**
|
||
* Determine the type of a character in a keypath.
|
||
*
|
||
* @param {Char} ch
|
||
* @return {String} type
|
||
*/
|
||
|
||
function getPathCharType(ch) {
|
||
if (ch === undefined) {
|
||
return 'eof';
|
||
}
|
||
|
||
var code = ch.charCodeAt(0);
|
||
|
||
switch (code) {
|
||
case 0x5B: // [
|
||
case 0x5D: // ]
|
||
case 0x2E: // .
|
||
case 0x22: // "
|
||
case 0x27: // '
|
||
case 0x30:
|
||
// 0
|
||
return ch;
|
||
|
||
case 0x5F: // _
|
||
case 0x24:
|
||
// $
|
||
return 'ident';
|
||
|
||
case 0x20: // Space
|
||
case 0x09: // Tab
|
||
case 0x0A: // Newline
|
||
case 0x0D: // Return
|
||
case 0xA0: // No-break space
|
||
case 0xFEFF: // Byte Order Mark
|
||
case 0x2028: // Line Separator
|
||
case 0x2029:
|
||
// Paragraph Separator
|
||
return 'ws';
|
||
}
|
||
|
||
// a-z, A-Z
|
||
if (code >= 0x61 && code <= 0x7A || code >= 0x41 && code <= 0x5A) {
|
||
return 'ident';
|
||
}
|
||
|
||
// 1-9
|
||
if (code >= 0x31 && code <= 0x39) {
|
||
return 'number';
|
||
}
|
||
|
||
return 'else';
|
||
}
|
||
|
||
/**
|
||
* Format a subPath, return its plain form if it is
|
||
* a literal string or number. Otherwise prepend the
|
||
* dynamic indicator (*).
|
||
*
|
||
* @param {String} path
|
||
* @return {String}
|
||
*/
|
||
|
||
function formatSubPath(path) {
|
||
var trimmed = path.trim();
|
||
// invalid leading 0
|
||
if (path.charAt(0) === '0' && isNaN(path)) {
|
||
return false;
|
||
}
|
||
return isLiteral(trimmed) ? stripQuotes(trimmed) : '*' + trimmed;
|
||
}
|
||
|
||
/**
|
||
* Parse a string path into an array of segments
|
||
*
|
||
* @param {String} path
|
||
* @return {Array|undefined}
|
||
*/
|
||
|
||
function parse(path) {
|
||
var keys = [];
|
||
var index = -1;
|
||
var mode = BEFORE_PATH;
|
||
var subPathDepth = 0;
|
||
var c, newChar, key, type, transition, action, typeMap;
|
||
|
||
var actions = [];
|
||
|
||
actions[PUSH] = function () {
|
||
if (key !== undefined) {
|
||
keys.push(key);
|
||
key = undefined;
|
||
}
|
||
};
|
||
|
||
actions[APPEND] = function () {
|
||
if (key === undefined) {
|
||
key = newChar;
|
||
} else {
|
||
key += newChar;
|
||
}
|
||
};
|
||
|
||
actions[INC_SUB_PATH_DEPTH] = function () {
|
||
actions[APPEND]();
|
||
subPathDepth++;
|
||
};
|
||
|
||
actions[PUSH_SUB_PATH] = function () {
|
||
if (subPathDepth > 0) {
|
||
subPathDepth--;
|
||
mode = IN_SUB_PATH;
|
||
actions[APPEND]();
|
||
} else {
|
||
subPathDepth = 0;
|
||
key = formatSubPath(key);
|
||
if (key === false) {
|
||
return false;
|
||
} else {
|
||
actions[PUSH]();
|
||
}
|
||
}
|
||
};
|
||
|
||
function maybeUnescapeQuote() {
|
||
var nextChar = path[index + 1];
|
||
if (mode === IN_SINGLE_QUOTE && nextChar === "'" || mode === IN_DOUBLE_QUOTE && nextChar === '"') {
|
||
index++;
|
||
newChar = '\\' + nextChar;
|
||
actions[APPEND]();
|
||
return true;
|
||
}
|
||
}
|
||
|
||
while (mode != null) {
|
||
index++;
|
||
c = path[index];
|
||
|
||
if (c === '\\' && maybeUnescapeQuote()) {
|
||
continue;
|
||
}
|
||
|
||
type = getPathCharType(c);
|
||
typeMap = pathStateMachine[mode];
|
||
transition = typeMap[type] || typeMap['else'] || ERROR;
|
||
|
||
if (transition === ERROR) {
|
||
return; // parse error
|
||
}
|
||
|
||
mode = transition[0];
|
||
action = actions[transition[1]];
|
||
if (action) {
|
||
newChar = transition[2];
|
||
newChar = newChar === undefined ? c : newChar;
|
||
if (action() === false) {
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (mode === AFTER_PATH) {
|
||
keys.raw = path;
|
||
return keys;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* External parse that check for a cache hit first
|
||
*
|
||
* @param {String} path
|
||
* @return {Array|undefined}
|
||
*/
|
||
|
||
function parsePath(path) {
|
||
var hit = pathCache.get(path);
|
||
if (!hit) {
|
||
hit = parse(path);
|
||
if (hit) {
|
||
pathCache.put(path, hit);
|
||
}
|
||
}
|
||
return hit;
|
||
}
|
||
|
||
/**
|
||
* Get from an object from a path string
|
||
*
|
||
* @param {Object} obj
|
||
* @param {String} path
|
||
*/
|
||
|
||
function getPath(obj, path) {
|
||
return parseExpression(path).get(obj);
|
||
}
|
||
|
||
/**
|
||
* Warn against setting non-existent root path on a vm.
|
||
*/
|
||
|
||
var warnNonExistent;
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
warnNonExistent = function (path) {
|
||
warn('You are setting a non-existent path "' + path.raw + '" ' + 'on a vm instance. Consider pre-initializing the property ' + 'with the "data" option for more reliable reactivity ' + 'and better performance.');
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Set on an object from a path
|
||
*
|
||
* @param {Object} obj
|
||
* @param {String | Array} path
|
||
* @param {*} val
|
||
*/
|
||
|
||
function setPath(obj, path, val) {
|
||
var original = obj;
|
||
if (typeof path === 'string') {
|
||
path = parse(path);
|
||
}
|
||
if (!path || !isObject(obj)) {
|
||
return false;
|
||
}
|
||
var last, key;
|
||
for (var i = 0, l = path.length; i < l; i++) {
|
||
last = obj;
|
||
key = path[i];
|
||
if (key.charAt(0) === '*') {
|
||
key = parseExpression(key.slice(1)).get.call(original, original);
|
||
}
|
||
if (i < l - 1) {
|
||
obj = obj[key];
|
||
if (!isObject(obj)) {
|
||
obj = {};
|
||
if (process.env.NODE_ENV !== 'production' && last._isVue) {
|
||
warnNonExistent(path);
|
||
}
|
||
set(last, key, obj);
|
||
}
|
||
} else {
|
||
if (isArray(obj)) {
|
||
obj.$set(key, val);
|
||
} else if (key in obj) {
|
||
obj[key] = val;
|
||
} else {
|
||
if (process.env.NODE_ENV !== 'production' && obj._isVue) {
|
||
warnNonExistent(path);
|
||
}
|
||
set(obj, key, val);
|
||
}
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
var path = Object.freeze({
|
||
parsePath: parsePath,
|
||
getPath: getPath,
|
||
setPath: setPath
|
||
});
|
||
|
||
var expressionCache = new Cache(1000);
|
||
|
||
var allowedKeywords = 'Math,Date,this,true,false,null,undefined,Infinity,NaN,' + 'isNaN,isFinite,decodeURI,decodeURIComponent,encodeURI,' + 'encodeURIComponent,parseInt,parseFloat';
|
||
var allowedKeywordsRE = new RegExp('^(' + allowedKeywords.replace(/,/g, '\\b|') + '\\b)');
|
||
|
||
// keywords that don't make sense inside expressions
|
||
var improperKeywords = 'break,case,class,catch,const,continue,debugger,default,' + 'delete,do,else,export,extends,finally,for,function,if,' + 'import,in,instanceof,let,return,super,switch,throw,try,' + 'var,while,with,yield,enum,await,implements,package,' + 'proctected,static,interface,private,public';
|
||
var improperKeywordsRE = new RegExp('^(' + improperKeywords.replace(/,/g, '\\b|') + '\\b)');
|
||
|
||
var wsRE = /\s/g;
|
||
var newlineRE = /\n/g;
|
||
var saveRE = /[\{,]\s*[\w\$_]+\s*:|('(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`)|new |typeof |void /g;
|
||
var restoreRE = /"(\d+)"/g;
|
||
var pathTestRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\]|\[\d+\]|\[[A-Za-z_$][\w$]*\])*$/;
|
||
var identRE = /[^\w$\.](?:[A-Za-z_$][\w$]*)/g;
|
||
var booleanLiteralRE = /^(?:true|false)$/;
|
||
|
||
/**
|
||
* Save / Rewrite / Restore
|
||
*
|
||
* When rewriting paths found in an expression, it is
|
||
* possible for the same letter sequences to be found in
|
||
* strings and Object literal property keys. Therefore we
|
||
* remove and store these parts in a temporary array, and
|
||
* restore them after the path rewrite.
|
||
*/
|
||
|
||
var saved = [];
|
||
|
||
/**
|
||
* Save replacer
|
||
*
|
||
* The save regex can match two possible cases:
|
||
* 1. An opening object literal
|
||
* 2. A string
|
||
* If matched as a plain string, we need to escape its
|
||
* newlines, since the string needs to be preserved when
|
||
* generating the function body.
|
||
*
|
||
* @param {String} str
|
||
* @param {String} isString - str if matched as a string
|
||
* @return {String} - placeholder with index
|
||
*/
|
||
|
||
function save(str, isString) {
|
||
var i = saved.length;
|
||
saved[i] = isString ? str.replace(newlineRE, '\\n') : str;
|
||
return '"' + i + '"';
|
||
}
|
||
|
||
/**
|
||
* Path rewrite replacer
|
||
*
|
||
* @param {String} raw
|
||
* @return {String}
|
||
*/
|
||
|
||
function rewrite(raw) {
|
||
var c = raw.charAt(0);
|
||
var path = raw.slice(1);
|
||
if (allowedKeywordsRE.test(path)) {
|
||
return raw;
|
||
} else {
|
||
path = path.indexOf('"') > -1 ? path.replace(restoreRE, restore) : path;
|
||
return c + 'scope.' + path;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Restore replacer
|
||
*
|
||
* @param {String} str
|
||
* @param {String} i - matched save index
|
||
* @return {String}
|
||
*/
|
||
|
||
function restore(str, i) {
|
||
return saved[i];
|
||
}
|
||
|
||
/**
|
||
* Rewrite an expression, prefixing all path accessors with
|
||
* `scope.` and generate getter/setter functions.
|
||
*
|
||
* @param {String} exp
|
||
* @return {Function}
|
||
*/
|
||
|
||
function compileGetter(exp) {
|
||
if (improperKeywordsRE.test(exp)) {
|
||
process.env.NODE_ENV !== 'production' && warn('Avoid using reserved keywords in expression: ' + exp);
|
||
}
|
||
// reset state
|
||
saved.length = 0;
|
||
// save strings and object literal keys
|
||
var body = exp.replace(saveRE, save).replace(wsRE, '');
|
||
// rewrite all paths
|
||
// pad 1 space here becaue the regex matches 1 extra char
|
||
body = (' ' + body).replace(identRE, rewrite).replace(restoreRE, restore);
|
||
return makeGetterFn(body);
|
||
}
|
||
|
||
/**
|
||
* Build a getter function. Requires eval.
|
||
*
|
||
* We isolate the try/catch so it doesn't affect the
|
||
* optimization of the parse function when it is not called.
|
||
*
|
||
* @param {String} body
|
||
* @return {Function|undefined}
|
||
*/
|
||
|
||
function makeGetterFn(body) {
|
||
try {
|
||
/* eslint-disable no-new-func */
|
||
return new Function('scope', 'return ' + body + ';');
|
||
/* eslint-enable no-new-func */
|
||
} catch (e) {
|
||
process.env.NODE_ENV !== 'production' && warn('Invalid expression. ' + 'Generated function body: ' + body);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Compile a setter function for the expression.
|
||
*
|
||
* @param {String} exp
|
||
* @return {Function|undefined}
|
||
*/
|
||
|
||
function compileSetter(exp) {
|
||
var path = parsePath(exp);
|
||
if (path) {
|
||
return function (scope, val) {
|
||
setPath(scope, path, val);
|
||
};
|
||
} else {
|
||
process.env.NODE_ENV !== 'production' && warn('Invalid setter expression: ' + exp);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Parse an expression into re-written getter/setters.
|
||
*
|
||
* @param {String} exp
|
||
* @param {Boolean} needSet
|
||
* @return {Function}
|
||
*/
|
||
|
||
function parseExpression(exp, needSet) {
|
||
exp = exp.trim();
|
||
// try cache
|
||
var hit = expressionCache.get(exp);
|
||
if (hit) {
|
||
if (needSet && !hit.set) {
|
||
hit.set = compileSetter(hit.exp);
|
||
}
|
||
return hit;
|
||
}
|
||
var res = { exp: exp };
|
||
res.get = isSimplePath(exp) && exp.indexOf('[') < 0
|
||
// optimized super simple getter
|
||
? makeGetterFn('scope.' + exp)
|
||
// dynamic getter
|
||
: compileGetter(exp);
|
||
if (needSet) {
|
||
res.set = compileSetter(exp);
|
||
}
|
||
expressionCache.put(exp, res);
|
||
return res;
|
||
}
|
||
|
||
/**
|
||
* Check if an expression is a simple path.
|
||
*
|
||
* @param {String} exp
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
function isSimplePath(exp) {
|
||
return pathTestRE.test(exp) &&
|
||
// don't treat true/false as paths
|
||
!booleanLiteralRE.test(exp) &&
|
||
// Math constants e.g. Math.PI, Math.E etc.
|
||
exp.slice(0, 5) !== 'Math.';
|
||
}
|
||
|
||
var expression = Object.freeze({
|
||
parseExpression: parseExpression,
|
||
isSimplePath: isSimplePath
|
||
});
|
||
|
||
// we have two separate queues: one for directive updates
|
||
// and one for user watcher registered via $watch().
|
||
// we want to guarantee directive updates to be called
|
||
// before user watchers so that when user watchers are
|
||
// triggered, the DOM would have already been in updated
|
||
// state.
|
||
var queue = [];
|
||
var userQueue = [];
|
||
var has = {};
|
||
var circular = {};
|
||
var waiting = false;
|
||
var internalQueueDepleted = false;
|
||
|
||
/**
|
||
* Reset the batcher's state.
|
||
*/
|
||
|
||
function resetBatcherState() {
|
||
queue = [];
|
||
userQueue = [];
|
||
has = {};
|
||
circular = {};
|
||
waiting = internalQueueDepleted = false;
|
||
}
|
||
|
||
/**
|
||
* Flush both queues and run the watchers.
|
||
*/
|
||
|
||
function flushBatcherQueue() {
|
||
runBatcherQueue(queue);
|
||
internalQueueDepleted = true;
|
||
runBatcherQueue(userQueue);
|
||
// dev tool hook
|
||
/* istanbul ignore if */
|
||
if (devtools) {
|
||
devtools.emit('flush');
|
||
}
|
||
resetBatcherState();
|
||
}
|
||
|
||
/**
|
||
* Run the watchers in a single queue.
|
||
*
|
||
* @param {Array} queue
|
||
*/
|
||
|
||
function runBatcherQueue(queue) {
|
||
// do not cache length because more watchers might be pushed
|
||
// as we run existing watchers
|
||
for (var i = 0; i < queue.length; i++) {
|
||
var watcher = queue[i];
|
||
var id = watcher.id;
|
||
has[id] = null;
|
||
watcher.run();
|
||
// in dev build, check and stop circular updates.
|
||
if (process.env.NODE_ENV !== 'production' && has[id] != null) {
|
||
circular[id] = (circular[id] || 0) + 1;
|
||
if (circular[id] > config._maxUpdateCount) {
|
||
queue.splice(has[id], 1);
|
||
warn('You may have an infinite update loop for watcher ' + 'with expression: ' + watcher.expression);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Push a watcher into the watcher queue.
|
||
* Jobs with duplicate IDs will be skipped unless it's
|
||
* pushed when the queue is being flushed.
|
||
*
|
||
* @param {Watcher} watcher
|
||
* properties:
|
||
* - {Number} id
|
||
* - {Function} run
|
||
*/
|
||
|
||
function pushWatcher(watcher) {
|
||
var id = watcher.id;
|
||
if (has[id] == null) {
|
||
// if an internal watcher is pushed, but the internal
|
||
// queue is already depleted, we run it immediately.
|
||
if (internalQueueDepleted && !watcher.user) {
|
||
watcher.run();
|
||
return;
|
||
}
|
||
// push watcher into appropriate queue
|
||
var q = watcher.user ? userQueue : queue;
|
||
has[id] = q.length;
|
||
q.push(watcher);
|
||
// queue the flush
|
||
if (!waiting) {
|
||
waiting = true;
|
||
nextTick(flushBatcherQueue);
|
||
}
|
||
}
|
||
}
|
||
|
||
var uid$2 = 0;
|
||
|
||
/**
|
||
* A watcher parses an expression, collects dependencies,
|
||
* and fires callback when the expression value changes.
|
||
* This is used for both the $watch() api and directives.
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {String} expression
|
||
* @param {Function} cb
|
||
* @param {Object} options
|
||
* - {Array} filters
|
||
* - {Boolean} twoWay
|
||
* - {Boolean} deep
|
||
* - {Boolean} user
|
||
* - {Boolean} sync
|
||
* - {Boolean} lazy
|
||
* - {Function} [preProcess]
|
||
* - {Function} [postProcess]
|
||
* @constructor
|
||
*/
|
||
function Watcher(vm, expOrFn, cb, options) {
|
||
// mix in options
|
||
if (options) {
|
||
extend(this, options);
|
||
}
|
||
var isFn = typeof expOrFn === 'function';
|
||
this.vm = vm;
|
||
vm._watchers.push(this);
|
||
this.expression = isFn ? expOrFn.toString() : expOrFn;
|
||
this.cb = cb;
|
||
this.id = ++uid$2; // uid for batching
|
||
this.active = true;
|
||
this.dirty = this.lazy; // for lazy watchers
|
||
this.deps = Object.create(null);
|
||
this.newDeps = null;
|
||
this.prevError = null; // for async error stacks
|
||
// parse expression for getter/setter
|
||
if (isFn) {
|
||
this.getter = expOrFn;
|
||
this.setter = undefined;
|
||
} else {
|
||
var res = parseExpression(expOrFn, this.twoWay);
|
||
this.getter = res.get;
|
||
this.setter = res.set;
|
||
}
|
||
this.value = this.lazy ? undefined : this.get();
|
||
// state for avoiding false triggers for deep and Array
|
||
// watchers during vm._digest()
|
||
this.queued = this.shallow = false;
|
||
}
|
||
|
||
/**
|
||
* Add a dependency to this directive.
|
||
*
|
||
* @param {Dep} dep
|
||
*/
|
||
|
||
Watcher.prototype.addDep = function (dep) {
|
||
var id = dep.id;
|
||
if (!this.newDeps[id]) {
|
||
this.newDeps[id] = dep;
|
||
if (!this.deps[id]) {
|
||
this.deps[id] = dep;
|
||
dep.addSub(this);
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Evaluate the getter, and re-collect dependencies.
|
||
*/
|
||
|
||
Watcher.prototype.get = function () {
|
||
this.beforeGet();
|
||
var scope = this.scope || this.vm;
|
||
var value;
|
||
try {
|
||
value = this.getter.call(scope, scope);
|
||
} catch (e) {
|
||
if (process.env.NODE_ENV !== 'production' && config.warnExpressionErrors) {
|
||
warn('Error when evaluating expression "' + this.expression + '". ' + (config.debug ? '' : 'Turn on debug mode to see stack trace.'), e);
|
||
}
|
||
}
|
||
// "touch" every property so they are all tracked as
|
||
// dependencies for deep watching
|
||
if (this.deep) {
|
||
traverse(value);
|
||
}
|
||
if (this.preProcess) {
|
||
value = this.preProcess(value);
|
||
}
|
||
if (this.filters) {
|
||
value = scope._applyFilters(value, null, this.filters, false);
|
||
}
|
||
if (this.postProcess) {
|
||
value = this.postProcess(value);
|
||
}
|
||
this.afterGet();
|
||
return value;
|
||
};
|
||
|
||
/**
|
||
* Set the corresponding value with the setter.
|
||
*
|
||
* @param {*} value
|
||
*/
|
||
|
||
Watcher.prototype.set = function (value) {
|
||
var scope = this.scope || this.vm;
|
||
if (this.filters) {
|
||
value = scope._applyFilters(value, this.value, this.filters, true);
|
||
}
|
||
try {
|
||
this.setter.call(scope, scope, value);
|
||
} catch (e) {
|
||
if (process.env.NODE_ENV !== 'production' && config.warnExpressionErrors) {
|
||
warn('Error when evaluating setter "' + this.expression + '"', e);
|
||
}
|
||
}
|
||
// two-way sync for v-for alias
|
||
var forContext = scope.$forContext;
|
||
if (forContext && forContext.alias === this.expression) {
|
||
if (forContext.filters) {
|
||
process.env.NODE_ENV !== 'production' && warn('It seems you are using two-way binding on ' + 'a v-for alias (' + this.expression + '), and the ' + 'v-for has filters. This will not work properly. ' + 'Either remove the filters or use an array of ' + 'objects and bind to object properties instead.');
|
||
return;
|
||
}
|
||
forContext._withLock(function () {
|
||
if (scope.$key) {
|
||
// original is an object
|
||
forContext.rawValue[scope.$key] = value;
|
||
} else {
|
||
forContext.rawValue.$set(scope.$index, value);
|
||
}
|
||
});
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Prepare for dependency collection.
|
||
*/
|
||
|
||
Watcher.prototype.beforeGet = function () {
|
||
Dep.target = this;
|
||
this.newDeps = Object.create(null);
|
||
};
|
||
|
||
/**
|
||
* Clean up for dependency collection.
|
||
*/
|
||
|
||
Watcher.prototype.afterGet = function () {
|
||
Dep.target = null;
|
||
var ids = Object.keys(this.deps);
|
||
var i = ids.length;
|
||
while (i--) {
|
||
var id = ids[i];
|
||
if (!this.newDeps[id]) {
|
||
this.deps[id].removeSub(this);
|
||
}
|
||
}
|
||
this.deps = this.newDeps;
|
||
};
|
||
|
||
/**
|
||
* Subscriber interface.
|
||
* Will be called when a dependency changes.
|
||
*
|
||
* @param {Boolean} shallow
|
||
*/
|
||
|
||
Watcher.prototype.update = function (shallow) {
|
||
if (this.lazy) {
|
||
this.dirty = true;
|
||
} else if (this.sync || !config.async) {
|
||
this.run();
|
||
} else {
|
||
// if queued, only overwrite shallow with non-shallow,
|
||
// but not the other way around.
|
||
this.shallow = this.queued ? shallow ? this.shallow : false : !!shallow;
|
||
this.queued = true;
|
||
// record before-push error stack in debug mode
|
||
/* istanbul ignore if */
|
||
if (process.env.NODE_ENV !== 'production' && config.debug) {
|
||
this.prevError = new Error('[vue] async stack trace');
|
||
}
|
||
pushWatcher(this);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Batcher job interface.
|
||
* Will be called by the batcher.
|
||
*/
|
||
|
||
Watcher.prototype.run = function () {
|
||
if (this.active) {
|
||
var value = this.get();
|
||
if (value !== this.value ||
|
||
// Deep watchers and watchers on Object/Arrays should fire even
|
||
// when the value is the same, because the value may
|
||
// have mutated; but only do so if this is a
|
||
// non-shallow update (caused by a vm digest).
|
||
(isObject(value) || this.deep) && !this.shallow) {
|
||
// set new value
|
||
var oldValue = this.value;
|
||
this.value = value;
|
||
// in debug + async mode, when a watcher callbacks
|
||
// throws, we also throw the saved before-push error
|
||
// so the full cross-tick stack trace is available.
|
||
var prevError = this.prevError;
|
||
/* istanbul ignore if */
|
||
if (process.env.NODE_ENV !== 'production' && config.debug && prevError) {
|
||
this.prevError = null;
|
||
try {
|
||
this.cb.call(this.vm, value, oldValue);
|
||
} catch (e) {
|
||
nextTick(function () {
|
||
throw prevError;
|
||
}, 0);
|
||
throw e;
|
||
}
|
||
} else {
|
||
this.cb.call(this.vm, value, oldValue);
|
||
}
|
||
}
|
||
this.queued = this.shallow = false;
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Evaluate the value of the watcher.
|
||
* This only gets called for lazy watchers.
|
||
*/
|
||
|
||
Watcher.prototype.evaluate = function () {
|
||
// avoid overwriting another watcher that is being
|
||
// collected.
|
||
var current = Dep.target;
|
||
this.value = this.get();
|
||
this.dirty = false;
|
||
Dep.target = current;
|
||
};
|
||
|
||
/**
|
||
* Depend on all deps collected by this watcher.
|
||
*/
|
||
|
||
Watcher.prototype.depend = function () {
|
||
var depIds = Object.keys(this.deps);
|
||
var i = depIds.length;
|
||
while (i--) {
|
||
this.deps[depIds[i]].depend();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Remove self from all dependencies' subcriber list.
|
||
*/
|
||
|
||
Watcher.prototype.teardown = function () {
|
||
if (this.active) {
|
||
// remove self from vm's watcher list
|
||
// this is a somewhat expensive operation so we skip it
|
||
// if the vm is being destroyed or is performing a v-for
|
||
// re-render (the watcher list is then filtered by v-for).
|
||
if (!this.vm._isBeingDestroyed && !this.vm._vForRemoving) {
|
||
this.vm._watchers.$remove(this);
|
||
}
|
||
var depIds = Object.keys(this.deps);
|
||
var i = depIds.length;
|
||
while (i--) {
|
||
this.deps[depIds[i]].removeSub(this);
|
||
}
|
||
this.active = false;
|
||
this.vm = this.cb = this.value = null;
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Recrusively traverse an object to evoke all converted
|
||
* getters, so that every nested property inside the object
|
||
* is collected as a "deep" dependency.
|
||
*
|
||
* @param {*} val
|
||
*/
|
||
|
||
function traverse(val) {
|
||
var i, keys;
|
||
if (isArray(val)) {
|
||
i = val.length;
|
||
while (i--) traverse(val[i]);
|
||
} else if (isObject(val)) {
|
||
keys = Object.keys(val);
|
||
i = keys.length;
|
||
while (i--) traverse(val[keys[i]]);
|
||
}
|
||
}
|
||
|
||
var text$1 = {
|
||
|
||
bind: function bind() {
|
||
this.attr = this.el.nodeType === 3 ? 'data' : 'textContent';
|
||
},
|
||
|
||
update: function update(value) {
|
||
this.el[this.attr] = _toString(value);
|
||
}
|
||
};
|
||
|
||
var templateCache = new Cache(1000);
|
||
var idSelectorCache = new Cache(1000);
|
||
|
||
var map = {
|
||
efault: [0, '', ''],
|
||
legend: [1, '<fieldset>', '</fieldset>'],
|
||
tr: [2, '<table><tbody>', '</tbody></table>'],
|
||
col: [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>']
|
||
};
|
||
|
||
map.td = map.th = [3, '<table><tbody><tr>', '</tr></tbody></table>'];
|
||
|
||
map.option = map.optgroup = [1, '<select multiple="multiple">', '</select>'];
|
||
|
||
map.thead = map.tbody = map.colgroup = map.caption = map.tfoot = [1, '<table>', '</table>'];
|
||
|
||
map.g = map.defs = map.symbol = map.use = map.image = map.text = map.circle = map.ellipse = map.line = map.path = map.polygon = map.polyline = map.rect = [1, '<svg ' + 'xmlns="http://www.w3.org/2000/svg" ' + 'xmlns:xlink="http://www.w3.org/1999/xlink" ' + 'xmlns:ev="http://www.w3.org/2001/xml-events"' + 'version="1.1">', '</svg>'];
|
||
|
||
/**
|
||
* Check if a node is a supported template node with a
|
||
* DocumentFragment content.
|
||
*
|
||
* @param {Node} node
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
function isRealTemplate(node) {
|
||
return isTemplate(node) && isFragment(node.content);
|
||
}
|
||
|
||
var tagRE$1 = /<([\w:]+)/;
|
||
var entityRE = /&#?\w+?;/;
|
||
|
||
/**
|
||
* Convert a string template to a DocumentFragment.
|
||
* Determines correct wrapping by tag types. Wrapping
|
||
* strategy found in jQuery & component/domify.
|
||
*
|
||
* @param {String} templateString
|
||
* @param {Boolean} raw
|
||
* @return {DocumentFragment}
|
||
*/
|
||
|
||
function stringToFragment(templateString, raw) {
|
||
// try a cache hit first
|
||
var cacheKey = raw ? templateString : templateString.trim();
|
||
var hit = templateCache.get(cacheKey);
|
||
if (hit) {
|
||
return hit;
|
||
}
|
||
|
||
var frag = document.createDocumentFragment();
|
||
var tagMatch = templateString.match(tagRE$1);
|
||
var entityMatch = entityRE.test(templateString);
|
||
|
||
if (!tagMatch && !entityMatch) {
|
||
// text only, return a single text node.
|
||
frag.appendChild(document.createTextNode(templateString));
|
||
} else {
|
||
var tag = tagMatch && tagMatch[1];
|
||
var wrap = map[tag] || map.efault;
|
||
var depth = wrap[0];
|
||
var prefix = wrap[1];
|
||
var suffix = wrap[2];
|
||
var node = document.createElement('div');
|
||
|
||
node.innerHTML = prefix + templateString + suffix;
|
||
while (depth--) {
|
||
node = node.lastChild;
|
||
}
|
||
|
||
var child;
|
||
/* eslint-disable no-cond-assign */
|
||
while (child = node.firstChild) {
|
||
/* eslint-enable no-cond-assign */
|
||
frag.appendChild(child);
|
||
}
|
||
}
|
||
if (!raw) {
|
||
trimNode(frag);
|
||
}
|
||
templateCache.put(cacheKey, frag);
|
||
return frag;
|
||
}
|
||
|
||
/**
|
||
* Convert a template node to a DocumentFragment.
|
||
*
|
||
* @param {Node} node
|
||
* @return {DocumentFragment}
|
||
*/
|
||
|
||
function nodeToFragment(node) {
|
||
// if its a template tag and the browser supports it,
|
||
// its content is already a document fragment.
|
||
if (isRealTemplate(node)) {
|
||
trimNode(node.content);
|
||
return node.content;
|
||
}
|
||
// script template
|
||
if (node.tagName === 'SCRIPT') {
|
||
return stringToFragment(node.textContent);
|
||
}
|
||
// normal node, clone it to avoid mutating the original
|
||
var clonedNode = cloneNode(node);
|
||
var frag = document.createDocumentFragment();
|
||
var child;
|
||
/* eslint-disable no-cond-assign */
|
||
while (child = clonedNode.firstChild) {
|
||
/* eslint-enable no-cond-assign */
|
||
frag.appendChild(child);
|
||
}
|
||
trimNode(frag);
|
||
return frag;
|
||
}
|
||
|
||
// Test for the presence of the Safari template cloning bug
|
||
// https://bugs.webkit.org/showug.cgi?id=137755
|
||
var hasBrokenTemplate = (function () {
|
||
/* istanbul ignore else */
|
||
if (inBrowser) {
|
||
var a = document.createElement('div');
|
||
a.innerHTML = '<template>1</template>';
|
||
return !a.cloneNode(true).firstChild.innerHTML;
|
||
} else {
|
||
return false;
|
||
}
|
||
})();
|
||
|
||
// Test for IE10/11 textarea placeholder clone bug
|
||
var hasTextareaCloneBug = (function () {
|
||
/* istanbul ignore else */
|
||
if (inBrowser) {
|
||
var t = document.createElement('textarea');
|
||
t.placeholder = 't';
|
||
return t.cloneNode(true).value === 't';
|
||
} else {
|
||
return false;
|
||
}
|
||
})();
|
||
|
||
/**
|
||
* 1. Deal with Safari cloning nested <template> bug by
|
||
* manually cloning all template instances.
|
||
* 2. Deal with IE10/11 textarea placeholder bug by setting
|
||
* the correct value after cloning.
|
||
*
|
||
* @param {Element|DocumentFragment} node
|
||
* @return {Element|DocumentFragment}
|
||
*/
|
||
|
||
function cloneNode(node) {
|
||
if (!node.querySelectorAll) {
|
||
return node.cloneNode();
|
||
}
|
||
var res = node.cloneNode(true);
|
||
var i, original, cloned;
|
||
/* istanbul ignore if */
|
||
if (hasBrokenTemplate) {
|
||
var tempClone = res;
|
||
if (isRealTemplate(node)) {
|
||
node = node.content;
|
||
tempClone = res.content;
|
||
}
|
||
original = node.querySelectorAll('template');
|
||
if (original.length) {
|
||
cloned = tempClone.querySelectorAll('template');
|
||
i = cloned.length;
|
||
while (i--) {
|
||
cloned[i].parentNode.replaceChild(cloneNode(original[i]), cloned[i]);
|
||
}
|
||
}
|
||
}
|
||
/* istanbul ignore if */
|
||
if (hasTextareaCloneBug) {
|
||
if (node.tagName === 'TEXTAREA') {
|
||
res.value = node.value;
|
||
} else {
|
||
original = node.querySelectorAll('textarea');
|
||
if (original.length) {
|
||
cloned = res.querySelectorAll('textarea');
|
||
i = cloned.length;
|
||
while (i--) {
|
||
cloned[i].value = original[i].value;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
|
||
/**
|
||
* Process the template option and normalizes it into a
|
||
* a DocumentFragment that can be used as a partial or a
|
||
* instance template.
|
||
*
|
||
* @param {*} template
|
||
* Possible values include:
|
||
* - DocumentFragment object
|
||
* - Node object of type Template
|
||
* - id selector: '#some-template-id'
|
||
* - template string: '<div><span>{{msg}}</span></div>'
|
||
* @param {Boolean} shouldClone
|
||
* @param {Boolean} raw
|
||
* inline HTML interpolation. Do not check for id
|
||
* selector and keep whitespace in the string.
|
||
* @return {DocumentFragment|undefined}
|
||
*/
|
||
|
||
function parseTemplate(template, shouldClone, raw) {
|
||
var node, frag;
|
||
|
||
// if the template is already a document fragment,
|
||
// do nothing
|
||
if (isFragment(template)) {
|
||
trimNode(template);
|
||
return shouldClone ? cloneNode(template) : template;
|
||
}
|
||
|
||
if (typeof template === 'string') {
|
||
// id selector
|
||
if (!raw && template.charAt(0) === '#') {
|
||
// id selector can be cached too
|
||
frag = idSelectorCache.get(template);
|
||
if (!frag) {
|
||
node = document.getElementById(template.slice(1));
|
||
if (node) {
|
||
frag = nodeToFragment(node);
|
||
// save selector to cache
|
||
idSelectorCache.put(template, frag);
|
||
}
|
||
}
|
||
} else {
|
||
// normal string template
|
||
frag = stringToFragment(template, raw);
|
||
}
|
||
} else if (template.nodeType) {
|
||
// a direct node
|
||
frag = nodeToFragment(template);
|
||
}
|
||
|
||
return frag && shouldClone ? cloneNode(frag) : frag;
|
||
}
|
||
|
||
var template = Object.freeze({
|
||
cloneNode: cloneNode,
|
||
parseTemplate: parseTemplate
|
||
});
|
||
|
||
var html = {
|
||
|
||
bind: function bind() {
|
||
// a comment node means this is a binding for
|
||
// {{{ inline unescaped html }}}
|
||
if (this.el.nodeType === 8) {
|
||
// hold nodes
|
||
this.nodes = [];
|
||
// replace the placeholder with proper anchor
|
||
this.anchor = createAnchor('v-html');
|
||
replace(this.el, this.anchor);
|
||
}
|
||
},
|
||
|
||
update: function update(value) {
|
||
value = _toString(value);
|
||
if (this.nodes) {
|
||
this.swap(value);
|
||
} else {
|
||
this.el.innerHTML = value;
|
||
}
|
||
},
|
||
|
||
swap: function swap(value) {
|
||
// remove old nodes
|
||
var i = this.nodes.length;
|
||
while (i--) {
|
||
remove(this.nodes[i]);
|
||
}
|
||
// convert new value to a fragment
|
||
// do not attempt to retrieve from id selector
|
||
var frag = parseTemplate(value, true, true);
|
||
// save a reference to these nodes so we can remove later
|
||
this.nodes = toArray(frag.childNodes);
|
||
before(frag, this.anchor);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Abstraction for a partially-compiled fragment.
|
||
* Can optionally compile content with a child scope.
|
||
*
|
||
* @param {Function} linker
|
||
* @param {Vue} vm
|
||
* @param {DocumentFragment} frag
|
||
* @param {Vue} [host]
|
||
* @param {Object} [scope]
|
||
*/
|
||
function Fragment(linker, vm, frag, host, scope, parentFrag) {
|
||
this.children = [];
|
||
this.childFrags = [];
|
||
this.vm = vm;
|
||
this.scope = scope;
|
||
this.inserted = false;
|
||
this.parentFrag = parentFrag;
|
||
if (parentFrag) {
|
||
parentFrag.childFrags.push(this);
|
||
}
|
||
this.unlink = linker(vm, frag, host, scope, this);
|
||
var single = this.single = frag.childNodes.length === 1 &&
|
||
// do not go single mode if the only node is an anchor
|
||
!frag.childNodes[0].__v_anchor;
|
||
if (single) {
|
||
this.node = frag.childNodes[0];
|
||
this.before = singleBefore;
|
||
this.remove = singleRemove;
|
||
} else {
|
||
this.node = createAnchor('fragment-start');
|
||
this.end = createAnchor('fragment-end');
|
||
this.frag = frag;
|
||
prepend(this.node, frag);
|
||
frag.appendChild(this.end);
|
||
this.before = multiBefore;
|
||
this.remove = multiRemove;
|
||
}
|
||
this.node.__v_frag = this;
|
||
}
|
||
|
||
/**
|
||
* Call attach/detach for all components contained within
|
||
* this fragment. Also do so recursively for all child
|
||
* fragments.
|
||
*
|
||
* @param {Function} hook
|
||
*/
|
||
|
||
Fragment.prototype.callHook = function (hook) {
|
||
var i, l;
|
||
for (i = 0, l = this.childFrags.length; i < l; i++) {
|
||
this.childFrags[i].callHook(hook);
|
||
}
|
||
for (i = 0, l = this.children.length; i < l; i++) {
|
||
hook(this.children[i]);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Insert fragment before target, single node version
|
||
*
|
||
* @param {Node} target
|
||
* @param {Boolean} withTransition
|
||
*/
|
||
|
||
function singleBefore(target, withTransition) {
|
||
this.inserted = true;
|
||
var method = withTransition !== false ? beforeWithTransition : before;
|
||
method(this.node, target, this.vm);
|
||
if (inDoc(this.node)) {
|
||
this.callHook(attach);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Remove fragment, single node version
|
||
*/
|
||
|
||
function singleRemove() {
|
||
this.inserted = false;
|
||
var shouldCallRemove = inDoc(this.node);
|
||
var self = this;
|
||
this.beforeRemove();
|
||
removeWithTransition(this.node, this.vm, function () {
|
||
if (shouldCallRemove) {
|
||
self.callHook(detach);
|
||
}
|
||
self.destroy();
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Insert fragment before target, multi-nodes version
|
||
*
|
||
* @param {Node} target
|
||
* @param {Boolean} withTransition
|
||
*/
|
||
|
||
function multiBefore(target, withTransition) {
|
||
this.inserted = true;
|
||
var vm = this.vm;
|
||
var method = withTransition !== false ? beforeWithTransition : before;
|
||
mapNodeRange(this.node, this.end, function (node) {
|
||
method(node, target, vm);
|
||
});
|
||
if (inDoc(this.node)) {
|
||
this.callHook(attach);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Remove fragment, multi-nodes version
|
||
*/
|
||
|
||
function multiRemove() {
|
||
this.inserted = false;
|
||
var self = this;
|
||
var shouldCallRemove = inDoc(this.node);
|
||
this.beforeRemove();
|
||
removeNodeRange(this.node, this.end, this.vm, this.frag, function () {
|
||
if (shouldCallRemove) {
|
||
self.callHook(detach);
|
||
}
|
||
self.destroy();
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Prepare the fragment for removal.
|
||
*/
|
||
|
||
Fragment.prototype.beforeRemove = function () {
|
||
var i, l;
|
||
for (i = 0, l = this.childFrags.length; i < l; i++) {
|
||
// call the same method recursively on child
|
||
// fragments, depth-first
|
||
this.childFrags[i].beforeRemove(false);
|
||
}
|
||
for (i = 0, l = this.children.length; i < l; i++) {
|
||
// Call destroy for all contained instances,
|
||
// with remove:false and defer:true.
|
||
// Defer is necessary because we need to
|
||
// keep the children to call detach hooks
|
||
// on them.
|
||
this.children[i].$destroy(false, true);
|
||
}
|
||
var dirs = this.unlink.dirs;
|
||
for (i = 0, l = dirs.length; i < l; i++) {
|
||
// disable the watchers on all the directives
|
||
// so that the rendered content stays the same
|
||
// during removal.
|
||
dirs[i]._watcher && dirs[i]._watcher.teardown();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Destroy the fragment.
|
||
*/
|
||
|
||
Fragment.prototype.destroy = function () {
|
||
if (this.parentFrag) {
|
||
this.parentFrag.childFrags.$remove(this);
|
||
}
|
||
this.node.__v_frag = null;
|
||
this.unlink();
|
||
};
|
||
|
||
/**
|
||
* Call attach hook for a Vue instance.
|
||
*
|
||
* @param {Vue} child
|
||
*/
|
||
|
||
function attach(child) {
|
||
if (!child._isAttached) {
|
||
child._callHook('attached');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Call detach hook for a Vue instance.
|
||
*
|
||
* @param {Vue} child
|
||
*/
|
||
|
||
function detach(child) {
|
||
if (child._isAttached) {
|
||
child._callHook('detached');
|
||
}
|
||
}
|
||
|
||
var linkerCache = new Cache(5000);
|
||
|
||
/**
|
||
* A factory that can be used to create instances of a
|
||
* fragment. Caches the compiled linker if possible.
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {Element|String} el
|
||
*/
|
||
function FragmentFactory(vm, el) {
|
||
this.vm = vm;
|
||
var template;
|
||
var isString = typeof el === 'string';
|
||
if (isString || isTemplate(el)) {
|
||
template = parseTemplate(el, true);
|
||
} else {
|
||
template = document.createDocumentFragment();
|
||
template.appendChild(el);
|
||
}
|
||
this.template = template;
|
||
// linker can be cached, but only for components
|
||
var linker;
|
||
var cid = vm.constructor.cid;
|
||
if (cid > 0) {
|
||
var cacheId = cid + (isString ? el : getOuterHTML(el));
|
||
linker = linkerCache.get(cacheId);
|
||
if (!linker) {
|
||
linker = compile(template, vm.$options, true);
|
||
linkerCache.put(cacheId, linker);
|
||
}
|
||
} else {
|
||
linker = compile(template, vm.$options, true);
|
||
}
|
||
this.linker = linker;
|
||
}
|
||
|
||
/**
|
||
* Create a fragment instance with given host and scope.
|
||
*
|
||
* @param {Vue} host
|
||
* @param {Object} scope
|
||
* @param {Fragment} parentFrag
|
||
*/
|
||
|
||
FragmentFactory.prototype.create = function (host, scope, parentFrag) {
|
||
var frag = cloneNode(this.template);
|
||
return new Fragment(this.linker, this.vm, frag, host, scope, parentFrag);
|
||
};
|
||
|
||
var ON = 700;
|
||
var MODEL = 800;
|
||
var BIND = 850;
|
||
var TRANSITION = 1100;
|
||
var EL = 1500;
|
||
var COMPONENT = 1500;
|
||
var PARTIAL = 1750;
|
||
var FOR = 2000;
|
||
var IF = 2000;
|
||
var SLOT = 2100;
|
||
|
||
var uid$3 = 0;
|
||
|
||
var vFor = {
|
||
|
||
priority: FOR,
|
||
|
||
params: ['track-by', 'stagger', 'enter-stagger', 'leave-stagger'],
|
||
|
||
bind: function bind() {
|
||
// support "item in/of items" syntax
|
||
var inMatch = this.expression.match(/(.*) (?:in|of) (.*)/);
|
||
if (inMatch) {
|
||
var itMatch = inMatch[1].match(/\((.*),(.*)\)/);
|
||
if (itMatch) {
|
||
this.iterator = itMatch[1].trim();
|
||
this.alias = itMatch[2].trim();
|
||
} else {
|
||
this.alias = inMatch[1].trim();
|
||
}
|
||
this.expression = inMatch[2];
|
||
}
|
||
|
||
if (!this.alias) {
|
||
process.env.NODE_ENV !== 'production' && warn('Alias is required in v-for.');
|
||
return;
|
||
}
|
||
|
||
// uid as a cache identifier
|
||
this.id = '__v-for__' + ++uid$3;
|
||
|
||
// check if this is an option list,
|
||
// so that we know if we need to update the <select>'s
|
||
// v-model when the option list has changed.
|
||
// because v-model has a lower priority than v-for,
|
||
// the v-model is not bound here yet, so we have to
|
||
// retrive it in the actual updateModel() function.
|
||
var tag = this.el.tagName;
|
||
this.isOption = (tag === 'OPTION' || tag === 'OPTGROUP') && this.el.parentNode.tagName === 'SELECT';
|
||
|
||
// setup anchor nodes
|
||
this.start = createAnchor('v-for-start');
|
||
this.end = createAnchor('v-for-end');
|
||
replace(this.el, this.end);
|
||
before(this.start, this.end);
|
||
|
||
// cache
|
||
this.cache = Object.create(null);
|
||
|
||
// fragment factory
|
||
this.factory = new FragmentFactory(this.vm, this.el);
|
||
},
|
||
|
||
update: function update(data) {
|
||
this.diff(data);
|
||
this.updateRef();
|
||
this.updateModel();
|
||
},
|
||
|
||
/**
|
||
* Diff, based on new data and old data, determine the
|
||
* minimum amount of DOM manipulations needed to make the
|
||
* DOM reflect the new data Array.
|
||
*
|
||
* The algorithm diffs the new data Array by storing a
|
||
* hidden reference to an owner vm instance on previously
|
||
* seen data. This allows us to achieve O(n) which is
|
||
* better than a levenshtein distance based algorithm,
|
||
* which is O(m * n).
|
||
*
|
||
* @param {Array} data
|
||
*/
|
||
|
||
diff: function diff(data) {
|
||
// check if the Array was converted from an Object
|
||
var item = data[0];
|
||
var convertedFromObject = this.fromObject = isObject(item) && hasOwn(item, '$key') && hasOwn(item, '$value');
|
||
|
||
var trackByKey = this.params.trackBy;
|
||
var oldFrags = this.frags;
|
||
var frags = this.frags = new Array(data.length);
|
||
var alias = this.alias;
|
||
var iterator = this.iterator;
|
||
var start = this.start;
|
||
var end = this.end;
|
||
var inDocument = inDoc(start);
|
||
var init = !oldFrags;
|
||
var i, l, frag, key, value, primitive;
|
||
|
||
// First pass, go through the new Array and fill up
|
||
// the new frags array. If a piece of data has a cached
|
||
// instance for it, we reuse it. Otherwise build a new
|
||
// instance.
|
||
for (i = 0, l = data.length; i < l; i++) {
|
||
item = data[i];
|
||
key = convertedFromObject ? item.$key : null;
|
||
value = convertedFromObject ? item.$value : item;
|
||
primitive = !isObject(value);
|
||
frag = !init && this.getCachedFrag(value, i, key);
|
||
if (frag) {
|
||
// reusable fragment
|
||
frag.reused = true;
|
||
// update $index
|
||
frag.scope.$index = i;
|
||
// update $key
|
||
if (key) {
|
||
frag.scope.$key = key;
|
||
}
|
||
// update iterator
|
||
if (iterator) {
|
||
frag.scope[iterator] = key !== null ? key : i;
|
||
}
|
||
// update data for track-by, object repeat &
|
||
// primitive values.
|
||
if (trackByKey || convertedFromObject || primitive) {
|
||
frag.scope[alias] = value;
|
||
}
|
||
} else {
|
||
// new isntance
|
||
frag = this.create(value, alias, i, key);
|
||
frag.fresh = !init;
|
||
}
|
||
frags[i] = frag;
|
||
if (init) {
|
||
frag.before(end);
|
||
}
|
||
}
|
||
|
||
// we're done for the initial render.
|
||
if (init) {
|
||
return;
|
||
}
|
||
|
||
// Second pass, go through the old fragments and
|
||
// destroy those who are not reused (and remove them
|
||
// from cache)
|
||
var removalIndex = 0;
|
||
var totalRemoved = oldFrags.length - frags.length;
|
||
// when removing a large number of fragments, watcher removal
|
||
// turns out to be a perf bottleneck, so we batch the watcher
|
||
// removals into a single filter call!
|
||
this.vm._vForRemoving = true;
|
||
for (i = 0, l = oldFrags.length; i < l; i++) {
|
||
frag = oldFrags[i];
|
||
if (!frag.reused) {
|
||
this.deleteCachedFrag(frag);
|
||
this.remove(frag, removalIndex++, totalRemoved, inDocument);
|
||
}
|
||
}
|
||
this.vm._vForRemoving = false;
|
||
if (removalIndex) {
|
||
this.vm._watchers = this.vm._watchers.filter(function (w) {
|
||
return w.active;
|
||
});
|
||
}
|
||
|
||
// Final pass, move/insert new fragments into the
|
||
// right place.
|
||
var targetPrev, prevEl, currentPrev;
|
||
var insertionIndex = 0;
|
||
for (i = 0, l = frags.length; i < l; i++) {
|
||
frag = frags[i];
|
||
// this is the frag that we should be after
|
||
targetPrev = frags[i - 1];
|
||
prevEl = targetPrev ? targetPrev.staggerCb ? targetPrev.staggerAnchor : targetPrev.end || targetPrev.node : start;
|
||
if (frag.reused && !frag.staggerCb) {
|
||
currentPrev = findPrevFrag(frag, start, this.id);
|
||
if (currentPrev !== targetPrev && (!currentPrev ||
|
||
// optimization for moving a single item.
|
||
// thanks to suggestions by @livoras in #1807
|
||
findPrevFrag(currentPrev, start, this.id) !== targetPrev)) {
|
||
this.move(frag, prevEl);
|
||
}
|
||
} else {
|
||
// new instance, or still in stagger.
|
||
// insert with updated stagger index.
|
||
this.insert(frag, insertionIndex++, prevEl, inDocument);
|
||
}
|
||
frag.reused = frag.fresh = false;
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Create a new fragment instance.
|
||
*
|
||
* @param {*} value
|
||
* @param {String} alias
|
||
* @param {Number} index
|
||
* @param {String} [key]
|
||
* @return {Fragment}
|
||
*/
|
||
|
||
create: function create(value, alias, index, key) {
|
||
var host = this._host;
|
||
// create iteration scope
|
||
var parentScope = this._scope || this.vm;
|
||
var scope = Object.create(parentScope);
|
||
// ref holder for the scope
|
||
scope.$refs = Object.create(parentScope.$refs);
|
||
scope.$els = Object.create(parentScope.$els);
|
||
// make sure point $parent to parent scope
|
||
scope.$parent = parentScope;
|
||
// for two-way binding on alias
|
||
scope.$forContext = this;
|
||
// define scope properties
|
||
defineReactive(scope, alias, value);
|
||
defineReactive(scope, '$index', index);
|
||
if (key) {
|
||
defineReactive(scope, '$key', key);
|
||
} else if (scope.$key) {
|
||
// avoid accidental fallback
|
||
def(scope, '$key', null);
|
||
}
|
||
if (this.iterator) {
|
||
defineReactive(scope, this.iterator, key !== null ? key : index);
|
||
}
|
||
var frag = this.factory.create(host, scope, this._frag);
|
||
frag.forId = this.id;
|
||
this.cacheFrag(value, frag, index, key);
|
||
return frag;
|
||
},
|
||
|
||
/**
|
||
* Update the v-ref on owner vm.
|
||
*/
|
||
|
||
updateRef: function updateRef() {
|
||
var ref = this.descriptor.ref;
|
||
if (!ref) return;
|
||
var hash = (this._scope || this.vm).$refs;
|
||
var refs;
|
||
if (!this.fromObject) {
|
||
refs = this.frags.map(findVmFromFrag);
|
||
} else {
|
||
refs = {};
|
||
this.frags.forEach(function (frag) {
|
||
refs[frag.scope.$key] = findVmFromFrag(frag);
|
||
});
|
||
}
|
||
hash[ref] = refs;
|
||
},
|
||
|
||
/**
|
||
* For option lists, update the containing v-model on
|
||
* parent <select>.
|
||
*/
|
||
|
||
updateModel: function updateModel() {
|
||
if (this.isOption) {
|
||
var parent = this.start.parentNode;
|
||
var model = parent && parent.__v_model;
|
||
if (model) {
|
||
model.forceUpdate();
|
||
}
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Insert a fragment. Handles staggering.
|
||
*
|
||
* @param {Fragment} frag
|
||
* @param {Number} index
|
||
* @param {Node} prevEl
|
||
* @param {Boolean} inDocument
|
||
*/
|
||
|
||
insert: function insert(frag, index, prevEl, inDocument) {
|
||
if (frag.staggerCb) {
|
||
frag.staggerCb.cancel();
|
||
frag.staggerCb = null;
|
||
}
|
||
var staggerAmount = this.getStagger(frag, index, null, 'enter');
|
||
if (inDocument && staggerAmount) {
|
||
// create an anchor and insert it synchronously,
|
||
// so that we can resolve the correct order without
|
||
// worrying about some elements not inserted yet
|
||
var anchor = frag.staggerAnchor;
|
||
if (!anchor) {
|
||
anchor = frag.staggerAnchor = createAnchor('stagger-anchor');
|
||
anchor.__v_frag = frag;
|
||
}
|
||
after(anchor, prevEl);
|
||
var op = frag.staggerCb = cancellable(function () {
|
||
frag.staggerCb = null;
|
||
frag.before(anchor);
|
||
remove(anchor);
|
||
});
|
||
setTimeout(op, staggerAmount);
|
||
} else {
|
||
frag.before(prevEl.nextSibling);
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Remove a fragment. Handles staggering.
|
||
*
|
||
* @param {Fragment} frag
|
||
* @param {Number} index
|
||
* @param {Number} total
|
||
* @param {Boolean} inDocument
|
||
*/
|
||
|
||
remove: function remove(frag, index, total, inDocument) {
|
||
if (frag.staggerCb) {
|
||
frag.staggerCb.cancel();
|
||
frag.staggerCb = null;
|
||
// it's not possible for the same frag to be removed
|
||
// twice, so if we have a pending stagger callback,
|
||
// it means this frag is queued for enter but removed
|
||
// before its transition started. Since it is already
|
||
// destroyed, we can just leave it in detached state.
|
||
return;
|
||
}
|
||
var staggerAmount = this.getStagger(frag, index, total, 'leave');
|
||
if (inDocument && staggerAmount) {
|
||
var op = frag.staggerCb = cancellable(function () {
|
||
frag.staggerCb = null;
|
||
frag.remove();
|
||
});
|
||
setTimeout(op, staggerAmount);
|
||
} else {
|
||
frag.remove();
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Move a fragment to a new position.
|
||
* Force no transition.
|
||
*
|
||
* @param {Fragment} frag
|
||
* @param {Node} prevEl
|
||
*/
|
||
|
||
move: function move(frag, prevEl) {
|
||
// fix a common issue with Sortable:
|
||
// if prevEl doesn't have nextSibling, this means it's
|
||
// been dragged after the end anchor. Just re-position
|
||
// the end anchor to the end of the container.
|
||
/* istanbul ignore if */
|
||
if (!prevEl.nextSibling) {
|
||
this.end.parentNode.appendChild(this.end);
|
||
}
|
||
frag.before(prevEl.nextSibling, false);
|
||
},
|
||
|
||
/**
|
||
* Cache a fragment using track-by or the object key.
|
||
*
|
||
* @param {*} value
|
||
* @param {Fragment} frag
|
||
* @param {Number} index
|
||
* @param {String} [key]
|
||
*/
|
||
|
||
cacheFrag: function cacheFrag(value, frag, index, key) {
|
||
var trackByKey = this.params.trackBy;
|
||
var cache = this.cache;
|
||
var primitive = !isObject(value);
|
||
var id;
|
||
if (key || trackByKey || primitive) {
|
||
id = trackByKey ? trackByKey === '$index' ? index : value[trackByKey] : key || value;
|
||
if (!cache[id]) {
|
||
cache[id] = frag;
|
||
} else if (trackByKey !== '$index') {
|
||
process.env.NODE_ENV !== 'production' && this.warnDuplicate(value);
|
||
}
|
||
} else {
|
||
id = this.id;
|
||
if (hasOwn(value, id)) {
|
||
if (value[id] === null) {
|
||
value[id] = frag;
|
||
} else {
|
||
process.env.NODE_ENV !== 'production' && this.warnDuplicate(value);
|
||
}
|
||
} else {
|
||
def(value, id, frag);
|
||
}
|
||
}
|
||
frag.raw = value;
|
||
},
|
||
|
||
/**
|
||
* Get a cached fragment from the value/index/key
|
||
*
|
||
* @param {*} value
|
||
* @param {Number} index
|
||
* @param {String} key
|
||
* @return {Fragment}
|
||
*/
|
||
|
||
getCachedFrag: function getCachedFrag(value, index, key) {
|
||
var trackByKey = this.params.trackBy;
|
||
var primitive = !isObject(value);
|
||
var frag;
|
||
if (key || trackByKey || primitive) {
|
||
var id = trackByKey ? trackByKey === '$index' ? index : value[trackByKey] : key || value;
|
||
frag = this.cache[id];
|
||
} else {
|
||
frag = value[this.id];
|
||
}
|
||
if (frag && (frag.reused || frag.fresh)) {
|
||
process.env.NODE_ENV !== 'production' && this.warnDuplicate(value);
|
||
}
|
||
return frag;
|
||
},
|
||
|
||
/**
|
||
* Delete a fragment from cache.
|
||
*
|
||
* @param {Fragment} frag
|
||
*/
|
||
|
||
deleteCachedFrag: function deleteCachedFrag(frag) {
|
||
var value = frag.raw;
|
||
var trackByKey = this.params.trackBy;
|
||
var scope = frag.scope;
|
||
var index = scope.$index;
|
||
// fix #948: avoid accidentally fall through to
|
||
// a parent repeater which happens to have $key.
|
||
var key = hasOwn(scope, '$key') && scope.$key;
|
||
var primitive = !isObject(value);
|
||
if (trackByKey || key || primitive) {
|
||
var id = trackByKey ? trackByKey === '$index' ? index : value[trackByKey] : key || value;
|
||
this.cache[id] = null;
|
||
} else {
|
||
value[this.id] = null;
|
||
frag.raw = null;
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Get the stagger amount for an insertion/removal.
|
||
*
|
||
* @param {Fragment} frag
|
||
* @param {Number} index
|
||
* @param {Number} total
|
||
* @param {String} type
|
||
*/
|
||
|
||
getStagger: function getStagger(frag, index, total, type) {
|
||
type = type + 'Stagger';
|
||
var trans = frag.node.__v_trans;
|
||
var hooks = trans && trans.hooks;
|
||
var hook = hooks && (hooks[type] || hooks.stagger);
|
||
return hook ? hook.call(frag, index, total) : index * parseInt(this.params[type] || this.params.stagger, 10);
|
||
},
|
||
|
||
/**
|
||
* Pre-process the value before piping it through the
|
||
* filters. This is passed to and called by the watcher.
|
||
*/
|
||
|
||
_preProcess: function _preProcess(value) {
|
||
// regardless of type, store the un-filtered raw value.
|
||
this.rawValue = value;
|
||
return value;
|
||
},
|
||
|
||
/**
|
||
* Post-process the value after it has been piped through
|
||
* the filters. This is passed to and called by the watcher.
|
||
*
|
||
* It is necessary for this to be called during the
|
||
* wathcer's dependency collection phase because we want
|
||
* the v-for to update when the source Object is mutated.
|
||
*/
|
||
|
||
_postProcess: function _postProcess(value) {
|
||
if (isArray(value)) {
|
||
return value;
|
||
} else if (isPlainObject(value)) {
|
||
// convert plain object to array.
|
||
var keys = Object.keys(value);
|
||
var i = keys.length;
|
||
var res = new Array(i);
|
||
var key;
|
||
while (i--) {
|
||
key = keys[i];
|
||
res[i] = {
|
||
$key: key,
|
||
$value: value[key]
|
||
};
|
||
}
|
||
return res;
|
||
} else {
|
||
if (typeof value === 'number' && !isNaN(value)) {
|
||
value = range(value);
|
||
}
|
||
return value || [];
|
||
}
|
||
},
|
||
|
||
unbind: function unbind() {
|
||
if (this.descriptor.ref) {
|
||
(this._scope || this.vm).$refs[this.descriptor.ref] = null;
|
||
}
|
||
if (this.frags) {
|
||
var i = this.frags.length;
|
||
var frag;
|
||
while (i--) {
|
||
frag = this.frags[i];
|
||
this.deleteCachedFrag(frag);
|
||
frag.destroy();
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Helper to find the previous element that is a fragment
|
||
* anchor. This is necessary because a destroyed frag's
|
||
* element could still be lingering in the DOM before its
|
||
* leaving transition finishes, but its inserted flag
|
||
* should have been set to false so we can skip them.
|
||
*
|
||
* If this is a block repeat, we want to make sure we only
|
||
* return frag that is bound to this v-for. (see #929)
|
||
*
|
||
* @param {Fragment} frag
|
||
* @param {Comment|Text} anchor
|
||
* @param {String} id
|
||
* @return {Fragment}
|
||
*/
|
||
|
||
function findPrevFrag(frag, anchor, id) {
|
||
var el = frag.node.previousSibling;
|
||
/* istanbul ignore if */
|
||
if (!el) return;
|
||
frag = el.__v_frag;
|
||
while ((!frag || frag.forId !== id || !frag.inserted) && el !== anchor) {
|
||
el = el.previousSibling;
|
||
/* istanbul ignore if */
|
||
if (!el) return;
|
||
frag = el.__v_frag;
|
||
}
|
||
return frag;
|
||
}
|
||
|
||
/**
|
||
* Find a vm from a fragment.
|
||
*
|
||
* @param {Fragment} frag
|
||
* @return {Vue|undefined}
|
||
*/
|
||
|
||
function findVmFromFrag(frag) {
|
||
var node = frag.node;
|
||
// handle multi-node frag
|
||
if (frag.end) {
|
||
while (!node.__vue__ && node !== frag.end && node.nextSibling) {
|
||
node = node.nextSibling;
|
||
}
|
||
}
|
||
return node.__vue__;
|
||
}
|
||
|
||
/**
|
||
* Create a range array from given number.
|
||
*
|
||
* @param {Number} n
|
||
* @return {Array}
|
||
*/
|
||
|
||
function range(n) {
|
||
var i = -1;
|
||
var ret = new Array(Math.floor(n));
|
||
while (++i < n) {
|
||
ret[i] = i;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
vFor.warnDuplicate = function (value) {
|
||
warn('Duplicate value found in v-for="' + this.descriptor.raw + '": ' + JSON.stringify(value) + '. Use track-by="$index" if ' + 'you are expecting duplicate values.');
|
||
};
|
||
}
|
||
|
||
var vIf = {
|
||
|
||
priority: IF,
|
||
|
||
bind: function bind() {
|
||
var el = this.el;
|
||
if (!el.__vue__) {
|
||
// check else block
|
||
var next = el.nextElementSibling;
|
||
if (next && getAttr(next, 'v-else') !== null) {
|
||
remove(next);
|
||
this.elseFactory = new FragmentFactory(next._context || this.vm, next);
|
||
}
|
||
// check main block
|
||
this.anchor = createAnchor('v-if');
|
||
replace(el, this.anchor);
|
||
this.factory = new FragmentFactory(this.vm, el);
|
||
} else {
|
||
process.env.NODE_ENV !== 'production' && warn('v-if="' + this.expression + '" cannot be ' + 'used on an instance root element.');
|
||
this.invalid = true;
|
||
}
|
||
},
|
||
|
||
update: function update(value) {
|
||
if (this.invalid) return;
|
||
if (value) {
|
||
if (!this.frag) {
|
||
this.insert();
|
||
}
|
||
} else {
|
||
this.remove();
|
||
}
|
||
},
|
||
|
||
insert: function insert() {
|
||
if (this.elseFrag) {
|
||
this.elseFrag.remove();
|
||
this.elseFrag = null;
|
||
}
|
||
this.frag = this.factory.create(this._host, this._scope, this._frag);
|
||
this.frag.before(this.anchor);
|
||
},
|
||
|
||
remove: function remove() {
|
||
if (this.frag) {
|
||
this.frag.remove();
|
||
this.frag = null;
|
||
}
|
||
if (this.elseFactory && !this.elseFrag) {
|
||
this.elseFrag = this.elseFactory.create(this._host, this._scope, this._frag);
|
||
this.elseFrag.before(this.anchor);
|
||
}
|
||
},
|
||
|
||
unbind: function unbind() {
|
||
if (this.frag) {
|
||
this.frag.destroy();
|
||
}
|
||
if (this.elseFrag) {
|
||
this.elseFrag.destroy();
|
||
}
|
||
}
|
||
};
|
||
|
||
var show = {
|
||
|
||
bind: function bind() {
|
||
// check else block
|
||
var next = this.el.nextElementSibling;
|
||
if (next && getAttr(next, 'v-else') !== null) {
|
||
this.elseEl = next;
|
||
}
|
||
},
|
||
|
||
update: function update(value) {
|
||
this.apply(this.el, value);
|
||
if (this.elseEl) {
|
||
this.apply(this.elseEl, !value);
|
||
}
|
||
},
|
||
|
||
apply: function apply(el, value) {
|
||
if (inDoc(el)) {
|
||
applyTransition(el, value ? 1 : -1, toggle, this.vm);
|
||
} else {
|
||
toggle();
|
||
}
|
||
function toggle() {
|
||
el.style.display = value ? '' : 'none';
|
||
}
|
||
}
|
||
};
|
||
|
||
var text$2 = {
|
||
|
||
bind: function bind() {
|
||
var self = this;
|
||
var el = this.el;
|
||
var isRange = el.type === 'range';
|
||
var lazy = this.params.lazy;
|
||
var number = this.params.number;
|
||
var debounce = this.params.debounce;
|
||
|
||
// handle composition events.
|
||
// http://blog.evanyou.me/2014/01/03/composition-event/
|
||
// skip this for Android because it handles composition
|
||
// events quite differently. Android doesn't trigger
|
||
// composition events for language input methods e.g.
|
||
// Chinese, but instead triggers them for spelling
|
||
// suggestions... (see Discussion/#162)
|
||
var composing = false;
|
||
if (!isAndroid && !isRange) {
|
||
this.on('compositionstart', function () {
|
||
composing = true;
|
||
});
|
||
this.on('compositionend', function () {
|
||
composing = false;
|
||
// in IE11 the "compositionend" event fires AFTER
|
||
// the "input" event, so the input handler is blocked
|
||
// at the end... have to call it here.
|
||
//
|
||
// #1327: in lazy mode this is unecessary.
|
||
if (!lazy) {
|
||
self.listener();
|
||
}
|
||
});
|
||
}
|
||
|
||
// prevent messing with the input when user is typing,
|
||
// and force update on blur.
|
||
this.focused = false;
|
||
if (!isRange && !lazy) {
|
||
this.on('focus', function () {
|
||
self.focused = true;
|
||
});
|
||
this.on('blur', function () {
|
||
self.focused = false;
|
||
});
|
||
}
|
||
|
||
// Now attach the main listener
|
||
this.listener = this.rawListener = function () {
|
||
if (composing || !self._bound) {
|
||
return;
|
||
}
|
||
var val = number || isRange ? toNumber(el.value) : el.value;
|
||
self.set(val);
|
||
// force update on next tick to avoid lock & same value
|
||
// also only update when user is not typing
|
||
nextTick(function () {
|
||
if (self._bound && !self.focused) {
|
||
self.update(self._watcher.value);
|
||
}
|
||
});
|
||
};
|
||
|
||
// apply debounce
|
||
if (debounce) {
|
||
this.listener = _debounce(this.listener, debounce);
|
||
}
|
||
|
||
// Support jQuery events, since jQuery.trigger() doesn't
|
||
// trigger native events in some cases and some plugins
|
||
// rely on $.trigger()
|
||
//
|
||
// We want to make sure if a listener is attached using
|
||
// jQuery, it is also removed with jQuery, that's why
|
||
// we do the check for each directive instance and
|
||
// store that check result on itself. This also allows
|
||
// easier test coverage control by unsetting the global
|
||
// jQuery variable in tests.
|
||
this.hasjQuery = typeof jQuery === 'function';
|
||
if (this.hasjQuery) {
|
||
var method = jQuery.fn.on ? 'on' : 'bind';
|
||
jQuery(el)[method]('change', this.rawListener);
|
||
if (!lazy) {
|
||
jQuery(el)[method]('input', this.listener);
|
||
}
|
||
} else {
|
||
this.on('change', this.rawListener);
|
||
if (!lazy) {
|
||
this.on('input', this.listener);
|
||
}
|
||
}
|
||
|
||
// IE9 doesn't fire input event on backspace/del/cut
|
||
if (!lazy && isIE9) {
|
||
this.on('cut', function () {
|
||
nextTick(self.listener);
|
||
});
|
||
this.on('keyup', function (e) {
|
||
if (e.keyCode === 46 || e.keyCode === 8) {
|
||
self.listener();
|
||
}
|
||
});
|
||
}
|
||
|
||
// set initial value if present
|
||
if (el.hasAttribute('value') || el.tagName === 'TEXTAREA' && el.value.trim()) {
|
||
this.afterBind = this.listener;
|
||
}
|
||
},
|
||
|
||
update: function update(value) {
|
||
this.el.value = _toString(value);
|
||
},
|
||
|
||
unbind: function unbind() {
|
||
var el = this.el;
|
||
if (this.hasjQuery) {
|
||
var method = jQuery.fn.off ? 'off' : 'unbind';
|
||
jQuery(el)[method]('change', this.listener);
|
||
jQuery(el)[method]('input', this.listener);
|
||
}
|
||
}
|
||
};
|
||
|
||
var radio = {
|
||
|
||
bind: function bind() {
|
||
var self = this;
|
||
var el = this.el;
|
||
|
||
this.getValue = function () {
|
||
// value overwrite via v-bind:value
|
||
if (el.hasOwnProperty('_value')) {
|
||
return el._value;
|
||
}
|
||
var val = el.value;
|
||
if (self.params.number) {
|
||
val = toNumber(val);
|
||
}
|
||
return val;
|
||
};
|
||
|
||
this.listener = function () {
|
||
self.set(self.getValue());
|
||
};
|
||
this.on('change', this.listener);
|
||
|
||
if (el.hasAttribute('checked')) {
|
||
this.afterBind = this.listener;
|
||
}
|
||
},
|
||
|
||
update: function update(value) {
|
||
this.el.checked = looseEqual(value, this.getValue());
|
||
}
|
||
};
|
||
|
||
var select = {
|
||
|
||
bind: function bind() {
|
||
var self = this;
|
||
var el = this.el;
|
||
|
||
// method to force update DOM using latest value.
|
||
this.forceUpdate = function () {
|
||
if (self._watcher) {
|
||
self.update(self._watcher.get());
|
||
}
|
||
};
|
||
|
||
// check if this is a multiple select
|
||
var multiple = this.multiple = el.hasAttribute('multiple');
|
||
|
||
// attach listener
|
||
this.listener = function () {
|
||
var value = getValue(el, multiple);
|
||
value = self.params.number ? isArray(value) ? value.map(toNumber) : toNumber(value) : value;
|
||
self.set(value);
|
||
};
|
||
this.on('change', this.listener);
|
||
|
||
// if has initial value, set afterBind
|
||
var initValue = getValue(el, multiple, true);
|
||
if (multiple && initValue.length || !multiple && initValue !== null) {
|
||
this.afterBind = this.listener;
|
||
}
|
||
|
||
// All major browsers except Firefox resets
|
||
// selectedIndex with value -1 to 0 when the element
|
||
// is appended to a new parent, therefore we have to
|
||
// force a DOM update whenever that happens...
|
||
this.vm.$on('hook:attached', this.forceUpdate);
|
||
},
|
||
|
||
update: function update(value) {
|
||
var el = this.el;
|
||
el.selectedIndex = -1;
|
||
var multi = this.multiple && isArray(value);
|
||
var options = el.options;
|
||
var i = options.length;
|
||
var op, val;
|
||
while (i--) {
|
||
op = options[i];
|
||
val = op.hasOwnProperty('_value') ? op._value : op.value;
|
||
/* eslint-disable eqeqeq */
|
||
op.selected = multi ? indexOf$1(value, val) > -1 : looseEqual(value, val);
|
||
/* eslint-enable eqeqeq */
|
||
}
|
||
},
|
||
|
||
unbind: function unbind() {
|
||
/* istanbul ignore next */
|
||
this.vm.$off('hook:attached', this.forceUpdate);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Get select value
|
||
*
|
||
* @param {SelectElement} el
|
||
* @param {Boolean} multi
|
||
* @param {Boolean} init
|
||
* @return {Array|*}
|
||
*/
|
||
|
||
function getValue(el, multi, init) {
|
||
var res = multi ? [] : null;
|
||
var op, val, selected;
|
||
for (var i = 0, l = el.options.length; i < l; i++) {
|
||
op = el.options[i];
|
||
selected = init ? op.hasAttribute('selected') : op.selected;
|
||
if (selected) {
|
||
val = op.hasOwnProperty('_value') ? op._value : op.value;
|
||
if (multi) {
|
||
res.push(val);
|
||
} else {
|
||
return val;
|
||
}
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
|
||
/**
|
||
* Native Array.indexOf uses strict equal, but in this
|
||
* case we need to match string/numbers with custom equal.
|
||
*
|
||
* @param {Array} arr
|
||
* @param {*} val
|
||
*/
|
||
|
||
function indexOf$1(arr, val) {
|
||
var i = arr.length;
|
||
while (i--) {
|
||
if (looseEqual(arr[i], val)) {
|
||
return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
var checkbox = {
|
||
|
||
bind: function bind() {
|
||
var self = this;
|
||
var el = this.el;
|
||
|
||
this.getValue = function () {
|
||
return el.hasOwnProperty('_value') ? el._value : self.params.number ? toNumber(el.value) : el.value;
|
||
};
|
||
|
||
function getBooleanValue() {
|
||
var val = el.checked;
|
||
if (val && el.hasOwnProperty('_trueValue')) {
|
||
return el._trueValue;
|
||
}
|
||
if (!val && el.hasOwnProperty('_falseValue')) {
|
||
return el._falseValue;
|
||
}
|
||
return val;
|
||
}
|
||
|
||
this.listener = function () {
|
||
var model = self._watcher.value;
|
||
if (isArray(model)) {
|
||
var val = self.getValue();
|
||
if (el.checked) {
|
||
if (indexOf(model, val) < 0) {
|
||
model.push(val);
|
||
}
|
||
} else {
|
||
model.$remove(val);
|
||
}
|
||
} else {
|
||
self.set(getBooleanValue());
|
||
}
|
||
};
|
||
|
||
this.on('change', this.listener);
|
||
if (el.hasAttribute('checked')) {
|
||
this.afterBind = this.listener;
|
||
}
|
||
},
|
||
|
||
update: function update(value) {
|
||
var el = this.el;
|
||
if (isArray(value)) {
|
||
el.checked = indexOf(value, this.getValue()) > -1;
|
||
} else {
|
||
if (el.hasOwnProperty('_trueValue')) {
|
||
el.checked = looseEqual(value, el._trueValue);
|
||
} else {
|
||
el.checked = !!value;
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
var handlers = {
|
||
text: text$2,
|
||
radio: radio,
|
||
select: select,
|
||
checkbox: checkbox
|
||
};
|
||
|
||
var model = {
|
||
|
||
priority: MODEL,
|
||
twoWay: true,
|
||
handlers: handlers,
|
||
params: ['lazy', 'number', 'debounce'],
|
||
|
||
/**
|
||
* Possible elements:
|
||
* <select>
|
||
* <textarea>
|
||
* <input type="*">
|
||
* - text
|
||
* - checkbox
|
||
* - radio
|
||
* - number
|
||
*/
|
||
|
||
bind: function bind() {
|
||
// friendly warning...
|
||
this.checkFilters();
|
||
if (this.hasRead && !this.hasWrite) {
|
||
process.env.NODE_ENV !== 'production' && warn('It seems you are using a read-only filter with ' + 'v-model. You might want to use a two-way filter ' + 'to ensure correct behavior.');
|
||
}
|
||
var el = this.el;
|
||
var tag = el.tagName;
|
||
var handler;
|
||
if (tag === 'INPUT') {
|
||
handler = handlers[el.type] || handlers.text;
|
||
} else if (tag === 'SELECT') {
|
||
handler = handlers.select;
|
||
} else if (tag === 'TEXTAREA') {
|
||
handler = handlers.text;
|
||
} else {
|
||
process.env.NODE_ENV !== 'production' && warn('v-model does not support element type: ' + tag);
|
||
return;
|
||
}
|
||
el.__v_model = this;
|
||
handler.bind.call(this);
|
||
this.update = handler.update;
|
||
this._unbind = handler.unbind;
|
||
},
|
||
|
||
/**
|
||
* Check read/write filter stats.
|
||
*/
|
||
|
||
checkFilters: function checkFilters() {
|
||
var filters = this.filters;
|
||
if (!filters) return;
|
||
var i = filters.length;
|
||
while (i--) {
|
||
var filter = resolveAsset(this.vm.$options, 'filters', filters[i].name);
|
||
if (typeof filter === 'function' || filter.read) {
|
||
this.hasRead = true;
|
||
}
|
||
if (filter.write) {
|
||
this.hasWrite = true;
|
||
}
|
||
}
|
||
},
|
||
|
||
unbind: function unbind() {
|
||
this.el.__v_model = null;
|
||
this._unbind && this._unbind();
|
||
}
|
||
};
|
||
|
||
// keyCode aliases
|
||
var keyCodes = {
|
||
esc: 27,
|
||
tab: 9,
|
||
enter: 13,
|
||
space: 32,
|
||
'delete': [8, 46],
|
||
up: 38,
|
||
left: 37,
|
||
right: 39,
|
||
down: 40
|
||
};
|
||
|
||
function keyFilter(handler, keys) {
|
||
var codes = keys.map(function (key) {
|
||
var charCode = key.charCodeAt(0);
|
||
if (charCode > 47 && charCode < 58) {
|
||
return parseInt(key, 10);
|
||
}
|
||
if (key.length === 1) {
|
||
charCode = key.toUpperCase().charCodeAt(0);
|
||
if (charCode > 64 && charCode < 91) {
|
||
return charCode;
|
||
}
|
||
}
|
||
return keyCodes[key];
|
||
});
|
||
codes = [].concat.apply([], codes);
|
||
return function keyHandler(e) {
|
||
if (codes.indexOf(e.keyCode) > -1) {
|
||
return handler.call(this, e);
|
||
}
|
||
};
|
||
}
|
||
|
||
function stopFilter(handler) {
|
||
return function stopHandler(e) {
|
||
e.stopPropagation();
|
||
return handler.call(this, e);
|
||
};
|
||
}
|
||
|
||
function preventFilter(handler) {
|
||
return function preventHandler(e) {
|
||
e.preventDefault();
|
||
return handler.call(this, e);
|
||
};
|
||
}
|
||
|
||
function selfFilter(handler) {
|
||
return function selfHandler(e) {
|
||
if (e.target === e.currentTarget) {
|
||
return handler.call(this, e);
|
||
}
|
||
};
|
||
}
|
||
|
||
var on$1 = {
|
||
|
||
priority: ON,
|
||
acceptStatement: true,
|
||
keyCodes: keyCodes,
|
||
|
||
bind: function bind() {
|
||
// deal with iframes
|
||
if (this.el.tagName === 'IFRAME' && this.arg !== 'load') {
|
||
var self = this;
|
||
this.iframeBind = function () {
|
||
on(self.el.contentWindow, self.arg, self.handler, self.modifiers.capture);
|
||
};
|
||
this.on('load', this.iframeBind);
|
||
}
|
||
},
|
||
|
||
update: function update(handler) {
|
||
// stub a noop for v-on with no value,
|
||
// e.g. @mousedown.prevent
|
||
if (!this.descriptor.raw) {
|
||
handler = function () {};
|
||
}
|
||
|
||
if (typeof handler !== 'function') {
|
||
process.env.NODE_ENV !== 'production' && warn('v-on:' + this.arg + '="' + this.expression + '" expects a function value, ' + 'got ' + handler);
|
||
return;
|
||
}
|
||
|
||
// apply modifiers
|
||
if (this.modifiers.stop) {
|
||
handler = stopFilter(handler);
|
||
}
|
||
if (this.modifiers.prevent) {
|
||
handler = preventFilter(handler);
|
||
}
|
||
if (this.modifiers.self) {
|
||
handler = selfFilter(handler);
|
||
}
|
||
// key filter
|
||
var keys = Object.keys(this.modifiers).filter(function (key) {
|
||
return key !== 'stop' && key !== 'prevent';
|
||
});
|
||
if (keys.length) {
|
||
handler = keyFilter(handler, keys);
|
||
}
|
||
|
||
this.reset();
|
||
this.handler = handler;
|
||
|
||
if (this.iframeBind) {
|
||
this.iframeBind();
|
||
} else {
|
||
on(this.el, this.arg, this.handler, this.modifiers.capture);
|
||
}
|
||
},
|
||
|
||
reset: function reset() {
|
||
var el = this.iframeBind ? this.el.contentWindow : this.el;
|
||
if (this.handler) {
|
||
off(el, this.arg, this.handler);
|
||
}
|
||
},
|
||
|
||
unbind: function unbind() {
|
||
this.reset();
|
||
}
|
||
};
|
||
|
||
var prefixes = ['-webkit-', '-moz-', '-ms-'];
|
||
var camelPrefixes = ['Webkit', 'Moz', 'ms'];
|
||
var importantRE = /!important;?$/;
|
||
var propCache = Object.create(null);
|
||
|
||
var testEl = null;
|
||
|
||
var style = {
|
||
|
||
deep: true,
|
||
|
||
update: function update(value) {
|
||
if (typeof value === 'string') {
|
||
this.el.style.cssText = value;
|
||
} else if (isArray(value)) {
|
||
this.handleObject(value.reduce(extend, {}));
|
||
} else {
|
||
this.handleObject(value || {});
|
||
}
|
||
},
|
||
|
||
handleObject: function handleObject(value) {
|
||
// cache object styles so that only changed props
|
||
// are actually updated.
|
||
var cache = this.cache || (this.cache = {});
|
||
var name, val;
|
||
for (name in cache) {
|
||
if (!(name in value)) {
|
||
this.handleSingle(name, null);
|
||
delete cache[name];
|
||
}
|
||
}
|
||
for (name in value) {
|
||
val = value[name];
|
||
if (val !== cache[name]) {
|
||
cache[name] = val;
|
||
this.handleSingle(name, val);
|
||
}
|
||
}
|
||
},
|
||
|
||
handleSingle: function handleSingle(prop, value) {
|
||
prop = normalize(prop);
|
||
if (!prop) return; // unsupported prop
|
||
// cast possible numbers/booleans into strings
|
||
if (value != null) value += '';
|
||
if (value) {
|
||
var isImportant = importantRE.test(value) ? 'important' : '';
|
||
if (isImportant) {
|
||
value = value.replace(importantRE, '').trim();
|
||
}
|
||
this.el.style.setProperty(prop, value, isImportant);
|
||
} else {
|
||
this.el.style.removeProperty(prop);
|
||
}
|
||
}
|
||
|
||
};
|
||
|
||
/**
|
||
* Normalize a CSS property name.
|
||
* - cache result
|
||
* - auto prefix
|
||
* - camelCase -> dash-case
|
||
*
|
||
* @param {String} prop
|
||
* @return {String}
|
||
*/
|
||
|
||
function normalize(prop) {
|
||
if (propCache[prop]) {
|
||
return propCache[prop];
|
||
}
|
||
var res = prefix(prop);
|
||
propCache[prop] = propCache[res] = res;
|
||
return res;
|
||
}
|
||
|
||
/**
|
||
* Auto detect the appropriate prefix for a CSS property.
|
||
* https://gist.github.com/paulirish/523692
|
||
*
|
||
* @param {String} prop
|
||
* @return {String}
|
||
*/
|
||
|
||
function prefix(prop) {
|
||
prop = hyphenate(prop);
|
||
var camel = camelize(prop);
|
||
var upper = camel.charAt(0).toUpperCase() + camel.slice(1);
|
||
if (!testEl) {
|
||
testEl = document.createElement('div');
|
||
}
|
||
var i = prefixes.length;
|
||
var prefixed;
|
||
while (i--) {
|
||
prefixed = camelPrefixes[i] + upper;
|
||
if (prefixed in testEl.style) {
|
||
return prefixes[i] + prop;
|
||
}
|
||
}
|
||
if (camel in testEl.style) {
|
||
return prop;
|
||
}
|
||
}
|
||
|
||
// xlink
|
||
var xlinkNS = 'http://www.w3.org/1999/xlink';
|
||
var xlinkRE = /^xlink:/;
|
||
|
||
// check for attributes that prohibit interpolations
|
||
var disallowedInterpAttrRE = /^v-|^:|^@|^(?:is|transition|transition-mode|debounce|track-by|stagger|enter-stagger|leave-stagger)$/;
|
||
// these attributes should also set their corresponding properties
|
||
// because they only affect the initial state of the element
|
||
var attrWithPropsRE = /^(?:value|checked|selected|muted)$/;
|
||
// these attributes expect enumrated values of "true" or "false"
|
||
// but are not boolean attributes
|
||
var enumeratedAttrRE = /^(?:draggable|contenteditable|spellcheck)$/;
|
||
|
||
// these attributes should set a hidden property for
|
||
// binding v-model to object values
|
||
var modelProps = {
|
||
value: '_value',
|
||
'true-value': '_trueValue',
|
||
'false-value': '_falseValue'
|
||
};
|
||
|
||
var bind$1 = {
|
||
|
||
priority: BIND,
|
||
|
||
bind: function bind() {
|
||
var attr = this.arg;
|
||
var tag = this.el.tagName;
|
||
// should be deep watch on object mode
|
||
if (!attr) {
|
||
this.deep = true;
|
||
}
|
||
// handle interpolation bindings
|
||
var descriptor = this.descriptor;
|
||
var tokens = descriptor.interp;
|
||
if (tokens) {
|
||
// handle interpolations with one-time tokens
|
||
if (descriptor.hasOneTime) {
|
||
this.expression = tokensToExp(tokens, this._scope || this.vm);
|
||
}
|
||
|
||
// only allow binding on native attributes
|
||
if (disallowedInterpAttrRE.test(attr) || attr === 'name' && (tag === 'PARTIAL' || tag === 'SLOT')) {
|
||
process.env.NODE_ENV !== 'production' && warn(attr + '="' + descriptor.raw + '": ' + 'attribute interpolation is not allowed in Vue.js ' + 'directives and special attributes.');
|
||
this.el.removeAttribute(attr);
|
||
this.invalid = true;
|
||
}
|
||
|
||
/* istanbul ignore if */
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
var raw = attr + '="' + descriptor.raw + '": ';
|
||
// warn src
|
||
if (attr === 'src') {
|
||
warn(raw + 'interpolation in "src" attribute will cause ' + 'a 404 request. Use v-bind:src instead.');
|
||
}
|
||
|
||
// warn style
|
||
if (attr === 'style') {
|
||
warn(raw + 'interpolation in "style" attribute will cause ' + 'the attribute to be discarded in Internet Explorer. ' + 'Use v-bind:style instead.');
|
||
}
|
||
}
|
||
}
|
||
},
|
||
|
||
update: function update(value) {
|
||
if (this.invalid) {
|
||
return;
|
||
}
|
||
var attr = this.arg;
|
||
if (this.arg) {
|
||
this.handleSingle(attr, value);
|
||
} else {
|
||
this.handleObject(value || {});
|
||
}
|
||
},
|
||
|
||
// share object handler with v-bind:class
|
||
handleObject: style.handleObject,
|
||
|
||
handleSingle: function handleSingle(attr, value) {
|
||
var el = this.el;
|
||
var interp = this.descriptor.interp;
|
||
if (this.modifiers.camel) {
|
||
attr = camelize(attr);
|
||
}
|
||
if (!interp && attrWithPropsRE.test(attr) && attr in el) {
|
||
el[attr] = attr === 'value' ? value == null // IE9 will set input.value to "null" for null...
|
||
? '' : value : value;
|
||
}
|
||
// set model props
|
||
var modelProp = modelProps[attr];
|
||
if (!interp && modelProp) {
|
||
el[modelProp] = value;
|
||
// update v-model if present
|
||
var model = el.__v_model;
|
||
if (model) {
|
||
model.listener();
|
||
}
|
||
}
|
||
// do not set value attribute for textarea
|
||
if (attr === 'value' && el.tagName === 'TEXTAREA') {
|
||
el.removeAttribute(attr);
|
||
return;
|
||
}
|
||
// update attribute
|
||
if (enumeratedAttrRE.test(attr)) {
|
||
el.setAttribute(attr, value ? 'true' : 'false');
|
||
} else if (value != null && value !== false) {
|
||
if (attr === 'class') {
|
||
// handle edge case #1960:
|
||
// class interpolation should not overwrite Vue transition class
|
||
if (el.__v_trans) {
|
||
value += ' ' + el.__v_trans.id + '-transition';
|
||
}
|
||
setClass(el, value);
|
||
} else if (xlinkRE.test(attr)) {
|
||
el.setAttributeNS(xlinkNS, attr, value === true ? '' : value);
|
||
} else {
|
||
el.setAttribute(attr, value === true ? '' : value);
|
||
}
|
||
} else {
|
||
el.removeAttribute(attr);
|
||
}
|
||
}
|
||
};
|
||
|
||
var el = {
|
||
|
||
priority: EL,
|
||
|
||
bind: function bind() {
|
||
/* istanbul ignore if */
|
||
if (!this.arg) {
|
||
return;
|
||
}
|
||
var id = this.id = camelize(this.arg);
|
||
var refs = (this._scope || this.vm).$els;
|
||
if (hasOwn(refs, id)) {
|
||
refs[id] = this.el;
|
||
} else {
|
||
defineReactive(refs, id, this.el);
|
||
}
|
||
},
|
||
|
||
unbind: function unbind() {
|
||
var refs = (this._scope || this.vm).$els;
|
||
if (refs[this.id] === this.el) {
|
||
refs[this.id] = null;
|
||
}
|
||
}
|
||
};
|
||
|
||
var ref = {
|
||
bind: function bind() {
|
||
process.env.NODE_ENV !== 'production' && warn('v-ref:' + this.arg + ' must be used on a child ' + 'component. Found on <' + this.el.tagName.toLowerCase() + '>.');
|
||
}
|
||
};
|
||
|
||
var cloak = {
|
||
bind: function bind() {
|
||
var el = this.el;
|
||
this.vm.$once('pre-hook:compiled', function () {
|
||
el.removeAttribute('v-cloak');
|
||
});
|
||
}
|
||
};
|
||
|
||
// must export plain object
|
||
var directives = {
|
||
text: text$1,
|
||
html: html,
|
||
'for': vFor,
|
||
'if': vIf,
|
||
show: show,
|
||
model: model,
|
||
on: on$1,
|
||
bind: bind$1,
|
||
el: el,
|
||
ref: ref,
|
||
cloak: cloak
|
||
};
|
||
|
||
var vClass = {
|
||
|
||
deep: true,
|
||
|
||
update: function update(value) {
|
||
if (value && typeof value === 'string') {
|
||
this.handleObject(stringToObject(value));
|
||
} else if (isPlainObject(value)) {
|
||
this.handleObject(value);
|
||
} else if (isArray(value)) {
|
||
this.handleArray(value);
|
||
} else {
|
||
this.cleanup();
|
||
}
|
||
},
|
||
|
||
handleObject: function handleObject(value) {
|
||
this.cleanup(value);
|
||
var keys = this.prevKeys = Object.keys(value);
|
||
for (var i = 0, l = keys.length; i < l; i++) {
|
||
var key = keys[i];
|
||
if (value[key]) {
|
||
addClass(this.el, key);
|
||
} else {
|
||
removeClass(this.el, key);
|
||
}
|
||
}
|
||
},
|
||
|
||
handleArray: function handleArray(value) {
|
||
this.cleanup(value);
|
||
for (var i = 0, l = value.length; i < l; i++) {
|
||
if (value[i]) {
|
||
addClass(this.el, value[i]);
|
||
}
|
||
}
|
||
this.prevKeys = value.slice();
|
||
},
|
||
|
||
cleanup: function cleanup(value) {
|
||
if (this.prevKeys) {
|
||
var i = this.prevKeys.length;
|
||
while (i--) {
|
||
var key = this.prevKeys[i];
|
||
if (key && (!value || !contains(value, key))) {
|
||
removeClass(this.el, key);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
function stringToObject(value) {
|
||
var res = {};
|
||
var keys = value.trim().split(/\s+/);
|
||
var i = keys.length;
|
||
while (i--) {
|
||
res[keys[i]] = true;
|
||
}
|
||
return res;
|
||
}
|
||
|
||
function contains(value, key) {
|
||
return isArray(value) ? value.indexOf(key) > -1 : hasOwn(value, key);
|
||
}
|
||
|
||
var component = {
|
||
|
||
priority: COMPONENT,
|
||
|
||
params: ['keep-alive', 'transition-mode', 'inline-template'],
|
||
|
||
/**
|
||
* Setup. Two possible usages:
|
||
*
|
||
* - static:
|
||
* <comp> or <div v-component="comp">
|
||
*
|
||
* - dynamic:
|
||
* <component :is="view">
|
||
*/
|
||
|
||
bind: function bind() {
|
||
if (!this.el.__vue__) {
|
||
// keep-alive cache
|
||
this.keepAlive = this.params.keepAlive;
|
||
if (this.keepAlive) {
|
||
this.cache = {};
|
||
}
|
||
// check inline-template
|
||
if (this.params.inlineTemplate) {
|
||
// extract inline template as a DocumentFragment
|
||
this.inlineTemplate = extractContent(this.el, true);
|
||
}
|
||
// component resolution related state
|
||
this.pendingComponentCb = this.Component = null;
|
||
// transition related state
|
||
this.pendingRemovals = 0;
|
||
this.pendingRemovalCb = null;
|
||
// create a ref anchor
|
||
this.anchor = createAnchor('v-component');
|
||
replace(this.el, this.anchor);
|
||
// remove is attribute.
|
||
// this is removed during compilation, but because compilation is
|
||
// cached, when the component is used elsewhere this attribute
|
||
// will remain at link time.
|
||
this.el.removeAttribute('is');
|
||
// remove ref, same as above
|
||
if (this.descriptor.ref) {
|
||
this.el.removeAttribute('v-ref:' + hyphenate(this.descriptor.ref));
|
||
}
|
||
// if static, build right now.
|
||
if (this.literal) {
|
||
this.setComponent(this.expression);
|
||
}
|
||
} else {
|
||
process.env.NODE_ENV !== 'production' && warn('cannot mount component "' + this.expression + '" ' + 'on already mounted element: ' + this.el);
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Public update, called by the watcher in the dynamic
|
||
* literal scenario, e.g. <component :is="view">
|
||
*/
|
||
|
||
update: function update(value) {
|
||
if (!this.literal) {
|
||
this.setComponent(value);
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Switch dynamic components. May resolve the component
|
||
* asynchronously, and perform transition based on
|
||
* specified transition mode. Accepts a few additional
|
||
* arguments specifically for vue-router.
|
||
*
|
||
* The callback is called when the full transition is
|
||
* finished.
|
||
*
|
||
* @param {String} value
|
||
* @param {Function} [cb]
|
||
*/
|
||
|
||
setComponent: function setComponent(value, cb) {
|
||
this.invalidatePending();
|
||
if (!value) {
|
||
// just remove current
|
||
this.unbuild(true);
|
||
this.remove(this.childVM, cb);
|
||
this.childVM = null;
|
||
} else {
|
||
var self = this;
|
||
this.resolveComponent(value, function () {
|
||
self.mountComponent(cb);
|
||
});
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Resolve the component constructor to use when creating
|
||
* the child vm.
|
||
*/
|
||
|
||
resolveComponent: function resolveComponent(id, cb) {
|
||
var self = this;
|
||
this.pendingComponentCb = cancellable(function (Component) {
|
||
self.ComponentName = Component.options.name || id;
|
||
self.Component = Component;
|
||
cb();
|
||
});
|
||
this.vm._resolveComponent(id, this.pendingComponentCb);
|
||
},
|
||
|
||
/**
|
||
* Create a new instance using the current constructor and
|
||
* replace the existing instance. This method doesn't care
|
||
* whether the new component and the old one are actually
|
||
* the same.
|
||
*
|
||
* @param {Function} [cb]
|
||
*/
|
||
|
||
mountComponent: function mountComponent(cb) {
|
||
// actual mount
|
||
this.unbuild(true);
|
||
var self = this;
|
||
var activateHooks = this.Component.options.activate;
|
||
var cached = this.getCached();
|
||
var newComponent = this.build();
|
||
if (activateHooks && !cached) {
|
||
this.waitingFor = newComponent;
|
||
callActivateHooks(activateHooks, newComponent, function () {
|
||
if (self.waitingFor !== newComponent) {
|
||
return;
|
||
}
|
||
self.waitingFor = null;
|
||
self.transition(newComponent, cb);
|
||
});
|
||
} else {
|
||
// update ref for kept-alive component
|
||
if (cached) {
|
||
newComponent._updateRef();
|
||
}
|
||
this.transition(newComponent, cb);
|
||
}
|
||
},
|
||
|
||
/**
|
||
* When the component changes or unbinds before an async
|
||
* constructor is resolved, we need to invalidate its
|
||
* pending callback.
|
||
*/
|
||
|
||
invalidatePending: function invalidatePending() {
|
||
if (this.pendingComponentCb) {
|
||
this.pendingComponentCb.cancel();
|
||
this.pendingComponentCb = null;
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Instantiate/insert a new child vm.
|
||
* If keep alive and has cached instance, insert that
|
||
* instance; otherwise build a new one and cache it.
|
||
*
|
||
* @param {Object} [extraOptions]
|
||
* @return {Vue} - the created instance
|
||
*/
|
||
|
||
build: function build(extraOptions) {
|
||
var cached = this.getCached();
|
||
if (cached) {
|
||
return cached;
|
||
}
|
||
if (this.Component) {
|
||
// default options
|
||
var options = {
|
||
name: this.ComponentName,
|
||
el: cloneNode(this.el),
|
||
template: this.inlineTemplate,
|
||
// make sure to add the child with correct parent
|
||
// if this is a transcluded component, its parent
|
||
// should be the transclusion host.
|
||
parent: this._host || this.vm,
|
||
// if no inline-template, then the compiled
|
||
// linker can be cached for better performance.
|
||
_linkerCachable: !this.inlineTemplate,
|
||
_ref: this.descriptor.ref,
|
||
_asComponent: true,
|
||
_isRouterView: this._isRouterView,
|
||
// if this is a transcluded component, context
|
||
// will be the common parent vm of this instance
|
||
// and its host.
|
||
_context: this.vm,
|
||
// if this is inside an inline v-for, the scope
|
||
// will be the intermediate scope created for this
|
||
// repeat fragment. this is used for linking props
|
||
// and container directives.
|
||
_scope: this._scope,
|
||
// pass in the owner fragment of this component.
|
||
// this is necessary so that the fragment can keep
|
||
// track of its contained components in order to
|
||
// call attach/detach hooks for them.
|
||
_frag: this._frag
|
||
};
|
||
// extra options
|
||
// in 1.0.0 this is used by vue-router only
|
||
/* istanbul ignore if */
|
||
if (extraOptions) {
|
||
extend(options, extraOptions);
|
||
}
|
||
var child = new this.Component(options);
|
||
if (this.keepAlive) {
|
||
this.cache[this.Component.cid] = child;
|
||
}
|
||
/* istanbul ignore if */
|
||
if (process.env.NODE_ENV !== 'production' && this.el.hasAttribute('transition') && child._isFragment) {
|
||
warn('Transitions will not work on a fragment instance. ' + 'Template: ' + child.$options.template);
|
||
}
|
||
return child;
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Try to get a cached instance of the current component.
|
||
*
|
||
* @return {Vue|undefined}
|
||
*/
|
||
|
||
getCached: function getCached() {
|
||
return this.keepAlive && this.cache[this.Component.cid];
|
||
},
|
||
|
||
/**
|
||
* Teardown the current child, but defers cleanup so
|
||
* that we can separate the destroy and removal steps.
|
||
*
|
||
* @param {Boolean} defer
|
||
*/
|
||
|
||
unbuild: function unbuild(defer) {
|
||
if (this.waitingFor) {
|
||
this.waitingFor.$destroy();
|
||
this.waitingFor = null;
|
||
}
|
||
var child = this.childVM;
|
||
if (!child || this.keepAlive) {
|
||
if (child) {
|
||
// remove ref
|
||
child._updateRef(true);
|
||
}
|
||
return;
|
||
}
|
||
// the sole purpose of `deferCleanup` is so that we can
|
||
// "deactivate" the vm right now and perform DOM removal
|
||
// later.
|
||
child.$destroy(false, defer);
|
||
},
|
||
|
||
/**
|
||
* Remove current destroyed child and manually do
|
||
* the cleanup after removal.
|
||
*
|
||
* @param {Function} cb
|
||
*/
|
||
|
||
remove: function remove(child, cb) {
|
||
var keepAlive = this.keepAlive;
|
||
if (child) {
|
||
// we may have a component switch when a previous
|
||
// component is still being transitioned out.
|
||
// we want to trigger only one lastest insertion cb
|
||
// when the existing transition finishes. (#1119)
|
||
this.pendingRemovals++;
|
||
this.pendingRemovalCb = cb;
|
||
var self = this;
|
||
child.$remove(function () {
|
||
self.pendingRemovals--;
|
||
if (!keepAlive) child._cleanup();
|
||
if (!self.pendingRemovals && self.pendingRemovalCb) {
|
||
self.pendingRemovalCb();
|
||
self.pendingRemovalCb = null;
|
||
}
|
||
});
|
||
} else if (cb) {
|
||
cb();
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Actually swap the components, depending on the
|
||
* transition mode. Defaults to simultaneous.
|
||
*
|
||
* @param {Vue} target
|
||
* @param {Function} [cb]
|
||
*/
|
||
|
||
transition: function transition(target, cb) {
|
||
var self = this;
|
||
var current = this.childVM;
|
||
// for devtool inspection
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
if (current) current._inactive = true;
|
||
target._inactive = false;
|
||
}
|
||
this.childVM = target;
|
||
switch (self.params.transitionMode) {
|
||
case 'in-out':
|
||
target.$before(self.anchor, function () {
|
||
self.remove(current, cb);
|
||
});
|
||
break;
|
||
case 'out-in':
|
||
self.remove(current, function () {
|
||
target.$before(self.anchor, cb);
|
||
});
|
||
break;
|
||
default:
|
||
self.remove(current);
|
||
target.$before(self.anchor, cb);
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Unbind.
|
||
*/
|
||
|
||
unbind: function unbind() {
|
||
this.invalidatePending();
|
||
// Do not defer cleanup when unbinding
|
||
this.unbuild();
|
||
// destroy all keep-alive cached instances
|
||
if (this.cache) {
|
||
for (var key in this.cache) {
|
||
this.cache[key].$destroy();
|
||
}
|
||
this.cache = null;
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Call activate hooks in order (asynchronous)
|
||
*
|
||
* @param {Array} hooks
|
||
* @param {Vue} vm
|
||
* @param {Function} cb
|
||
*/
|
||
|
||
function callActivateHooks(hooks, vm, cb) {
|
||
var total = hooks.length;
|
||
var called = 0;
|
||
hooks[0].call(vm, next);
|
||
function next() {
|
||
if (++called >= total) {
|
||
cb();
|
||
} else {
|
||
hooks[called].call(vm, next);
|
||
}
|
||
}
|
||
}
|
||
|
||
var bindingModes = config._propBindingModes;
|
||
|
||
var propDef = {
|
||
|
||
bind: function bind() {
|
||
var child = this.vm;
|
||
var parent = child._context;
|
||
// passed in from compiler directly
|
||
var prop = this.descriptor.prop;
|
||
var childKey = prop.path;
|
||
var parentKey = prop.parentPath;
|
||
var twoWay = prop.mode === bindingModes.TWO_WAY;
|
||
|
||
var parentWatcher = this.parentWatcher = new Watcher(parent, parentKey, function (val) {
|
||
val = coerceProp(prop, val);
|
||
if (assertProp(prop, val)) {
|
||
child[childKey] = val;
|
||
}
|
||
}, {
|
||
twoWay: twoWay,
|
||
filters: prop.filters,
|
||
// important: props need to be observed on the
|
||
// v-for scope if present
|
||
scope: this._scope
|
||
});
|
||
|
||
// set the child initial value.
|
||
initProp(child, prop, parentWatcher.value);
|
||
|
||
// setup two-way binding
|
||
if (twoWay) {
|
||
// important: defer the child watcher creation until
|
||
// the created hook (after data observation)
|
||
var self = this;
|
||
child.$once('pre-hook:created', function () {
|
||
self.childWatcher = new Watcher(child, childKey, function (val) {
|
||
parentWatcher.set(val);
|
||
}, {
|
||
// ensure sync upward before parent sync down.
|
||
// this is necessary in cases e.g. the child
|
||
// mutates a prop array, then replaces it. (#1683)
|
||
sync: true
|
||
});
|
||
});
|
||
}
|
||
},
|
||
|
||
unbind: function unbind() {
|
||
this.parentWatcher.teardown();
|
||
if (this.childWatcher) {
|
||
this.childWatcher.teardown();
|
||
}
|
||
}
|
||
};
|
||
|
||
var queue$1 = [];
|
||
var queued = false;
|
||
|
||
/**
|
||
* Push a job into the queue.
|
||
*
|
||
* @param {Function} job
|
||
*/
|
||
|
||
function pushJob(job) {
|
||
queue$1.push(job);
|
||
if (!queued) {
|
||
queued = true;
|
||
nextTick(flush);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Flush the queue, and do one forced reflow before
|
||
* triggering transitions.
|
||
*/
|
||
|
||
function flush() {
|
||
// Force layout
|
||
var f = document.documentElement.offsetHeight;
|
||
for (var i = 0; i < queue$1.length; i++) {
|
||
queue$1[i]();
|
||
}
|
||
queue$1 = [];
|
||
queued = false;
|
||
// dummy return, so js linters don't complain about
|
||
// unused variable f
|
||
return f;
|
||
}
|
||
|
||
var TYPE_TRANSITION = 'transition';
|
||
var TYPE_ANIMATION = 'animation';
|
||
var transDurationProp = transitionProp + 'Duration';
|
||
var animDurationProp = animationProp + 'Duration';
|
||
|
||
/**
|
||
* A Transition object that encapsulates the state and logic
|
||
* of the transition.
|
||
*
|
||
* @param {Element} el
|
||
* @param {String} id
|
||
* @param {Object} hooks
|
||
* @param {Vue} vm
|
||
*/
|
||
function Transition(el, id, hooks, vm) {
|
||
this.id = id;
|
||
this.el = el;
|
||
this.enterClass = hooks && hooks.enterClass || id + '-enter';
|
||
this.leaveClass = hooks && hooks.leaveClass || id + '-leave';
|
||
this.hooks = hooks;
|
||
this.vm = vm;
|
||
// async state
|
||
this.pendingCssEvent = this.pendingCssCb = this.cancel = this.pendingJsCb = this.op = this.cb = null;
|
||
this.justEntered = false;
|
||
this.entered = this.left = false;
|
||
this.typeCache = {};
|
||
// check css transition type
|
||
this.type = hooks && hooks.type;
|
||
/* istanbul ignore if */
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
if (this.type && this.type !== TYPE_TRANSITION && this.type !== TYPE_ANIMATION) {
|
||
warn('invalid CSS transition type for transition="' + this.id + '": ' + this.type);
|
||
}
|
||
}
|
||
// bind
|
||
var self = this;['enterNextTick', 'enterDone', 'leaveNextTick', 'leaveDone'].forEach(function (m) {
|
||
self[m] = bind(self[m], self);
|
||
});
|
||
}
|
||
|
||
var p$1 = Transition.prototype;
|
||
|
||
/**
|
||
* Start an entering transition.
|
||
*
|
||
* 1. enter transition triggered
|
||
* 2. call beforeEnter hook
|
||
* 3. add enter class
|
||
* 4. insert/show element
|
||
* 5. call enter hook (with possible explicit js callback)
|
||
* 6. reflow
|
||
* 7. based on transition type:
|
||
* - transition:
|
||
* remove class now, wait for transitionend,
|
||
* then done if there's no explicit js callback.
|
||
* - animation:
|
||
* wait for animationend, remove class,
|
||
* then done if there's no explicit js callback.
|
||
* - no css transition:
|
||
* done now if there's no explicit js callback.
|
||
* 8. wait for either done or js callback, then call
|
||
* afterEnter hook.
|
||
*
|
||
* @param {Function} op - insert/show the element
|
||
* @param {Function} [cb]
|
||
*/
|
||
|
||
p$1.enter = function (op, cb) {
|
||
this.cancelPending();
|
||
this.callHook('beforeEnter');
|
||
this.cb = cb;
|
||
addClass(this.el, this.enterClass);
|
||
op();
|
||
this.entered = false;
|
||
this.callHookWithCb('enter');
|
||
if (this.entered) {
|
||
return; // user called done synchronously.
|
||
}
|
||
this.cancel = this.hooks && this.hooks.enterCancelled;
|
||
pushJob(this.enterNextTick);
|
||
};
|
||
|
||
/**
|
||
* The "nextTick" phase of an entering transition, which is
|
||
* to be pushed into a queue and executed after a reflow so
|
||
* that removing the class can trigger a CSS transition.
|
||
*/
|
||
|
||
p$1.enterNextTick = function () {
|
||
// Important hack:
|
||
// in Chrome, if a just-entered element is applied the
|
||
// leave class while its interpolated property still has
|
||
// a very small value (within one frame), Chrome will
|
||
// skip the leave transition entirely and not firing the
|
||
// transtionend event. Therefore we need to protected
|
||
// against such cases using a one-frame timeout.
|
||
this.justEntered = true;
|
||
var self = this;
|
||
setTimeout(function () {
|
||
self.justEntered = false;
|
||
}, 17);
|
||
|
||
var enterDone = this.enterDone;
|
||
var type = this.getCssTransitionType(this.enterClass);
|
||
if (!this.pendingJsCb) {
|
||
if (type === TYPE_TRANSITION) {
|
||
// trigger transition by removing enter class now
|
||
removeClass(this.el, this.enterClass);
|
||
this.setupCssCb(transitionEndEvent, enterDone);
|
||
} else if (type === TYPE_ANIMATION) {
|
||
this.setupCssCb(animationEndEvent, enterDone);
|
||
} else {
|
||
enterDone();
|
||
}
|
||
} else if (type === TYPE_TRANSITION) {
|
||
removeClass(this.el, this.enterClass);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* The "cleanup" phase of an entering transition.
|
||
*/
|
||
|
||
p$1.enterDone = function () {
|
||
this.entered = true;
|
||
this.cancel = this.pendingJsCb = null;
|
||
removeClass(this.el, this.enterClass);
|
||
this.callHook('afterEnter');
|
||
if (this.cb) this.cb();
|
||
};
|
||
|
||
/**
|
||
* Start a leaving transition.
|
||
*
|
||
* 1. leave transition triggered.
|
||
* 2. call beforeLeave hook
|
||
* 3. add leave class (trigger css transition)
|
||
* 4. call leave hook (with possible explicit js callback)
|
||
* 5. reflow if no explicit js callback is provided
|
||
* 6. based on transition type:
|
||
* - transition or animation:
|
||
* wait for end event, remove class, then done if
|
||
* there's no explicit js callback.
|
||
* - no css transition:
|
||
* done if there's no explicit js callback.
|
||
* 7. wait for either done or js callback, then call
|
||
* afterLeave hook.
|
||
*
|
||
* @param {Function} op - remove/hide the element
|
||
* @param {Function} [cb]
|
||
*/
|
||
|
||
p$1.leave = function (op, cb) {
|
||
this.cancelPending();
|
||
this.callHook('beforeLeave');
|
||
this.op = op;
|
||
this.cb = cb;
|
||
addClass(this.el, this.leaveClass);
|
||
this.left = false;
|
||
this.callHookWithCb('leave');
|
||
if (this.left) {
|
||
return; // user called done synchronously.
|
||
}
|
||
this.cancel = this.hooks && this.hooks.leaveCancelled;
|
||
// only need to handle leaveDone if
|
||
// 1. the transition is already done (synchronously called
|
||
// by the user, which causes this.op set to null)
|
||
// 2. there's no explicit js callback
|
||
if (this.op && !this.pendingJsCb) {
|
||
// if a CSS transition leaves immediately after enter,
|
||
// the transitionend event never fires. therefore we
|
||
// detect such cases and end the leave immediately.
|
||
if (this.justEntered) {
|
||
this.leaveDone();
|
||
} else {
|
||
pushJob(this.leaveNextTick);
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* The "nextTick" phase of a leaving transition.
|
||
*/
|
||
|
||
p$1.leaveNextTick = function () {
|
||
var type = this.getCssTransitionType(this.leaveClass);
|
||
if (type) {
|
||
var event = type === TYPE_TRANSITION ? transitionEndEvent : animationEndEvent;
|
||
this.setupCssCb(event, this.leaveDone);
|
||
} else {
|
||
this.leaveDone();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* The "cleanup" phase of a leaving transition.
|
||
*/
|
||
|
||
p$1.leaveDone = function () {
|
||
this.left = true;
|
||
this.cancel = this.pendingJsCb = null;
|
||
this.op();
|
||
removeClass(this.el, this.leaveClass);
|
||
this.callHook('afterLeave');
|
||
if (this.cb) this.cb();
|
||
this.op = null;
|
||
};
|
||
|
||
/**
|
||
* Cancel any pending callbacks from a previously running
|
||
* but not finished transition.
|
||
*/
|
||
|
||
p$1.cancelPending = function () {
|
||
this.op = this.cb = null;
|
||
var hasPending = false;
|
||
if (this.pendingCssCb) {
|
||
hasPending = true;
|
||
off(this.el, this.pendingCssEvent, this.pendingCssCb);
|
||
this.pendingCssEvent = this.pendingCssCb = null;
|
||
}
|
||
if (this.pendingJsCb) {
|
||
hasPending = true;
|
||
this.pendingJsCb.cancel();
|
||
this.pendingJsCb = null;
|
||
}
|
||
if (hasPending) {
|
||
removeClass(this.el, this.enterClass);
|
||
removeClass(this.el, this.leaveClass);
|
||
}
|
||
if (this.cancel) {
|
||
this.cancel.call(this.vm, this.el);
|
||
this.cancel = null;
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Call a user-provided synchronous hook function.
|
||
*
|
||
* @param {String} type
|
||
*/
|
||
|
||
p$1.callHook = function (type) {
|
||
if (this.hooks && this.hooks[type]) {
|
||
this.hooks[type].call(this.vm, this.el);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Call a user-provided, potentially-async hook function.
|
||
* We check for the length of arguments to see if the hook
|
||
* expects a `done` callback. If true, the transition's end
|
||
* will be determined by when the user calls that callback;
|
||
* otherwise, the end is determined by the CSS transition or
|
||
* animation.
|
||
*
|
||
* @param {String} type
|
||
*/
|
||
|
||
p$1.callHookWithCb = function (type) {
|
||
var hook = this.hooks && this.hooks[type];
|
||
if (hook) {
|
||
if (hook.length > 1) {
|
||
this.pendingJsCb = cancellable(this[type + 'Done']);
|
||
}
|
||
hook.call(this.vm, this.el, this.pendingJsCb);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Get an element's transition type based on the
|
||
* calculated styles.
|
||
*
|
||
* @param {String} className
|
||
* @return {Number}
|
||
*/
|
||
|
||
p$1.getCssTransitionType = function (className) {
|
||
/* istanbul ignore if */
|
||
if (!transitionEndEvent ||
|
||
// skip CSS transitions if page is not visible -
|
||
// this solves the issue of transitionend events not
|
||
// firing until the page is visible again.
|
||
// pageVisibility API is supported in IE10+, same as
|
||
// CSS transitions.
|
||
document.hidden ||
|
||
// explicit js-only transition
|
||
this.hooks && this.hooks.css === false ||
|
||
// element is hidden
|
||
isHidden(this.el)) {
|
||
return;
|
||
}
|
||
var type = this.type || this.typeCache[className];
|
||
if (type) return type;
|
||
var inlineStyles = this.el.style;
|
||
var computedStyles = window.getComputedStyle(this.el);
|
||
var transDuration = inlineStyles[transDurationProp] || computedStyles[transDurationProp];
|
||
if (transDuration && transDuration !== '0s') {
|
||
type = TYPE_TRANSITION;
|
||
} else {
|
||
var animDuration = inlineStyles[animDurationProp] || computedStyles[animDurationProp];
|
||
if (animDuration && animDuration !== '0s') {
|
||
type = TYPE_ANIMATION;
|
||
}
|
||
}
|
||
if (type) {
|
||
this.typeCache[className] = type;
|
||
}
|
||
return type;
|
||
};
|
||
|
||
/**
|
||
* Setup a CSS transitionend/animationend callback.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} cb
|
||
*/
|
||
|
||
p$1.setupCssCb = function (event, cb) {
|
||
this.pendingCssEvent = event;
|
||
var self = this;
|
||
var el = this.el;
|
||
var onEnd = this.pendingCssCb = function (e) {
|
||
if (e.target === el) {
|
||
off(el, event, onEnd);
|
||
self.pendingCssEvent = self.pendingCssCb = null;
|
||
if (!self.pendingJsCb && cb) {
|
||
cb();
|
||
}
|
||
}
|
||
};
|
||
on(el, event, onEnd);
|
||
};
|
||
|
||
/**
|
||
* Check if an element is hidden - in that case we can just
|
||
* skip the transition alltogether.
|
||
*
|
||
* @param {Element} el
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
function isHidden(el) {
|
||
if (/svg$/.test(el.namespaceURI)) {
|
||
// SVG elements do not have offset(Width|Height)
|
||
// so we need to check the client rect
|
||
var rect = el.getBoundingClientRect();
|
||
return !(rect.width || rect.height);
|
||
} else {
|
||
return !(el.offsetWidth || el.offsetHeight || el.getClientRects().length);
|
||
}
|
||
}
|
||
|
||
var transition$1 = {
|
||
|
||
priority: TRANSITION,
|
||
|
||
update: function update(id, oldId) {
|
||
var el = this.el;
|
||
// resolve on owner vm
|
||
var hooks = resolveAsset(this.vm.$options, 'transitions', id);
|
||
id = id || 'v';
|
||
el.__v_trans = new Transition(el, id, hooks, this.vm);
|
||
if (oldId) {
|
||
removeClass(el, oldId + '-transition');
|
||
}
|
||
addClass(el, id + '-transition');
|
||
}
|
||
};
|
||
|
||
var internalDirectives = {
|
||
style: style,
|
||
'class': vClass,
|
||
component: component,
|
||
prop: propDef,
|
||
transition: transition$1
|
||
};
|
||
|
||
var propBindingModes = config._propBindingModes;
|
||
var empty = {};
|
||
|
||
// regexes
|
||
var identRE$1 = /^[$_a-zA-Z]+[\w$]*$/;
|
||
var settablePathRE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\[[^\[\]]+\])*$/;
|
||
|
||
/**
|
||
* Compile props on a root element and return
|
||
* a props link function.
|
||
*
|
||
* @param {Element|DocumentFragment} el
|
||
* @param {Array} propOptions
|
||
* @return {Function} propsLinkFn
|
||
*/
|
||
|
||
function compileProps(el, propOptions) {
|
||
var props = [];
|
||
var names = Object.keys(propOptions);
|
||
var i = names.length;
|
||
var options, name, attr, value, path, parsed, prop;
|
||
while (i--) {
|
||
name = names[i];
|
||
options = propOptions[name] || empty;
|
||
|
||
if (process.env.NODE_ENV !== 'production' && name === '$data') {
|
||
warn('Do not use $data as prop.');
|
||
continue;
|
||
}
|
||
|
||
// props could contain dashes, which will be
|
||
// interpreted as minus calculations by the parser
|
||
// so we need to camelize the path here
|
||
path = camelize(name);
|
||
if (!identRE$1.test(path)) {
|
||
process.env.NODE_ENV !== 'production' && warn('Invalid prop key: "' + name + '". Prop keys ' + 'must be valid identifiers.');
|
||
continue;
|
||
}
|
||
|
||
prop = {
|
||
name: name,
|
||
path: path,
|
||
options: options,
|
||
mode: propBindingModes.ONE_WAY,
|
||
raw: null
|
||
};
|
||
|
||
attr = hyphenate(name);
|
||
// first check dynamic version
|
||
if ((value = getBindAttr(el, attr)) === null) {
|
||
if ((value = getBindAttr(el, attr + '.sync')) !== null) {
|
||
prop.mode = propBindingModes.TWO_WAY;
|
||
} else if ((value = getBindAttr(el, attr + '.once')) !== null) {
|
||
prop.mode = propBindingModes.ONE_TIME;
|
||
}
|
||
}
|
||
if (value !== null) {
|
||
// has dynamic binding!
|
||
prop.raw = value;
|
||
parsed = parseDirective(value);
|
||
value = parsed.expression;
|
||
prop.filters = parsed.filters;
|
||
// check binding type
|
||
if (isLiteral(value) && !parsed.filters) {
|
||
// for expressions containing literal numbers and
|
||
// booleans, there's no need to setup a prop binding,
|
||
// so we can optimize them as a one-time set.
|
||
prop.optimizedLiteral = true;
|
||
} else {
|
||
prop.dynamic = true;
|
||
// check non-settable path for two-way bindings
|
||
if (process.env.NODE_ENV !== 'production' && prop.mode === propBindingModes.TWO_WAY && !settablePathRE.test(value)) {
|
||
prop.mode = propBindingModes.ONE_WAY;
|
||
warn('Cannot bind two-way prop with non-settable ' + 'parent path: ' + value);
|
||
}
|
||
}
|
||
prop.parentPath = value;
|
||
|
||
// warn required two-way
|
||
if (process.env.NODE_ENV !== 'production' && options.twoWay && prop.mode !== propBindingModes.TWO_WAY) {
|
||
warn('Prop "' + name + '" expects a two-way binding type.');
|
||
}
|
||
} else if ((value = getAttr(el, attr)) !== null) {
|
||
// has literal binding!
|
||
prop.raw = value;
|
||
} else if (process.env.NODE_ENV !== 'production') {
|
||
// check possible camelCase prop usage
|
||
var lowerCaseName = path.toLowerCase();
|
||
value = /[A-Z\-]/.test(name) && (el.getAttribute(lowerCaseName) || el.getAttribute(':' + lowerCaseName) || el.getAttribute('v-bind:' + lowerCaseName) || el.getAttribute(':' + lowerCaseName + '.once') || el.getAttribute('v-bind:' + lowerCaseName + '.once') || el.getAttribute(':' + lowerCaseName + '.sync') || el.getAttribute('v-bind:' + lowerCaseName + '.sync'));
|
||
if (value) {
|
||
warn('Possible usage error for prop `' + lowerCaseName + '` - ' + 'did you mean `' + attr + '`? HTML is case-insensitive, remember to use ' + 'kebab-case for props in templates.');
|
||
} else if (options.required) {
|
||
// warn missing required
|
||
warn('Missing required prop: ' + name);
|
||
}
|
||
}
|
||
// push prop
|
||
props.push(prop);
|
||
}
|
||
return makePropsLinkFn(props);
|
||
}
|
||
|
||
/**
|
||
* Build a function that applies props to a vm.
|
||
*
|
||
* @param {Array} props
|
||
* @return {Function} propsLinkFn
|
||
*/
|
||
|
||
function makePropsLinkFn(props) {
|
||
return function propsLinkFn(vm, scope) {
|
||
// store resolved props info
|
||
vm._props = {};
|
||
var i = props.length;
|
||
var prop, path, options, value, raw;
|
||
while (i--) {
|
||
prop = props[i];
|
||
raw = prop.raw;
|
||
path = prop.path;
|
||
options = prop.options;
|
||
vm._props[path] = prop;
|
||
if (raw === null) {
|
||
// initialize absent prop
|
||
initProp(vm, prop, getDefault(vm, options));
|
||
} else if (prop.dynamic) {
|
||
// dynamic prop
|
||
if (prop.mode === propBindingModes.ONE_TIME) {
|
||
// one time binding
|
||
value = (scope || vm._context || vm).$get(prop.parentPath);
|
||
initProp(vm, prop, value);
|
||
} else {
|
||
if (vm._context) {
|
||
// dynamic binding
|
||
vm._bindDir({
|
||
name: 'prop',
|
||
def: propDef,
|
||
prop: prop
|
||
}, null, null, scope); // el, host, scope
|
||
} else {
|
||
// root instance
|
||
initProp(vm, prop, vm.$get(prop.parentPath));
|
||
}
|
||
}
|
||
} else if (prop.optimizedLiteral) {
|
||
// optimized literal, cast it and just set once
|
||
var stripped = stripQuotes(raw);
|
||
value = stripped === raw ? toBoolean(toNumber(raw)) : stripped;
|
||
initProp(vm, prop, value);
|
||
} else {
|
||
// string literal, but we need to cater for
|
||
// Boolean props with no value
|
||
value = options.type === Boolean && raw === '' ? true : raw;
|
||
initProp(vm, prop, value);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Get the default value of a prop.
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {Object} options
|
||
* @return {*}
|
||
*/
|
||
|
||
function getDefault(vm, options) {
|
||
// no default, return undefined
|
||
if (!hasOwn(options, 'default')) {
|
||
// absent boolean value defaults to false
|
||
return options.type === Boolean ? false : undefined;
|
||
}
|
||
var def = options['default'];
|
||
// warn against non-factory defaults for Object & Array
|
||
if (isObject(def)) {
|
||
process.env.NODE_ENV !== 'production' && warn('Object/Array as default prop values will be shared ' + 'across multiple instances. Use a factory function ' + 'to return the default value instead.');
|
||
}
|
||
// call factory function for non-Function types
|
||
return typeof def === 'function' && options.type !== Function ? def.call(vm) : def;
|
||
}
|
||
|
||
// special binding prefixes
|
||
var bindRE = /^v-bind:|^:/;
|
||
var onRE = /^v-on:|^@/;
|
||
var dirAttrRE = /^v-([^:]+)(?:$|:(.*)$)/;
|
||
var modifierRE = /\.[^\.]+/g;
|
||
var transitionRE = /^(v-bind:|:)?transition$/;
|
||
|
||
// terminal directives
|
||
var terminalDirectives = ['for', 'if'];
|
||
|
||
// default directive priority
|
||
var DEFAULT_PRIORITY = 1000;
|
||
|
||
/**
|
||
* Compile a template and return a reusable composite link
|
||
* function, which recursively contains more link functions
|
||
* inside. This top level compile function would normally
|
||
* be called on instance root nodes, but can also be used
|
||
* for partial compilation if the partial argument is true.
|
||
*
|
||
* The returned composite link function, when called, will
|
||
* return an unlink function that tearsdown all directives
|
||
* created during the linking phase.
|
||
*
|
||
* @param {Element|DocumentFragment} el
|
||
* @param {Object} options
|
||
* @param {Boolean} partial
|
||
* @return {Function}
|
||
*/
|
||
|
||
function compile(el, options, partial) {
|
||
// link function for the node itself.
|
||
var nodeLinkFn = partial || !options._asComponent ? compileNode(el, options) : null;
|
||
// link function for the childNodes
|
||
var childLinkFn = !(nodeLinkFn && nodeLinkFn.terminal) && el.tagName !== 'SCRIPT' && el.hasChildNodes() ? compileNodeList(el.childNodes, options) : null;
|
||
|
||
/**
|
||
* A composite linker function to be called on a already
|
||
* compiled piece of DOM, which instantiates all directive
|
||
* instances.
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {Element|DocumentFragment} el
|
||
* @param {Vue} [host] - host vm of transcluded content
|
||
* @param {Object} [scope] - v-for scope
|
||
* @param {Fragment} [frag] - link context fragment
|
||
* @return {Function|undefined}
|
||
*/
|
||
|
||
return function compositeLinkFn(vm, el, host, scope, frag) {
|
||
// cache childNodes before linking parent, fix #657
|
||
var childNodes = toArray(el.childNodes);
|
||
// link
|
||
var dirs = linkAndCapture(function compositeLinkCapturer() {
|
||
if (nodeLinkFn) nodeLinkFn(vm, el, host, scope, frag);
|
||
if (childLinkFn) childLinkFn(vm, childNodes, host, scope, frag);
|
||
}, vm);
|
||
return makeUnlinkFn(vm, dirs);
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Apply a linker to a vm/element pair and capture the
|
||
* directives created during the process.
|
||
*
|
||
* @param {Function} linker
|
||
* @param {Vue} vm
|
||
*/
|
||
|
||
function linkAndCapture(linker, vm) {
|
||
/* istanbul ignore if */
|
||
if (process.env.NODE_ENV === 'production') {
|
||
// reset directives before every capture in production
|
||
// mode, so that when unlinking we don't need to splice
|
||
// them out (which turns out to be a perf hit).
|
||
// they are kept in development mode because they are
|
||
// useful for Vue's own tests.
|
||
vm._directives = [];
|
||
}
|
||
var originalDirCount = vm._directives.length;
|
||
linker();
|
||
var dirs = vm._directives.slice(originalDirCount);
|
||
dirs.sort(directiveComparator);
|
||
for (var i = 0, l = dirs.length; i < l; i++) {
|
||
dirs[i]._bind();
|
||
}
|
||
return dirs;
|
||
}
|
||
|
||
/**
|
||
* Directive priority sort comparator
|
||
*
|
||
* @param {Object} a
|
||
* @param {Object} b
|
||
*/
|
||
|
||
function directiveComparator(a, b) {
|
||
a = a.descriptor.def.priority || DEFAULT_PRIORITY;
|
||
b = b.descriptor.def.priority || DEFAULT_PRIORITY;
|
||
return a > b ? -1 : a === b ? 0 : 1;
|
||
}
|
||
|
||
/**
|
||
* Linker functions return an unlink function that
|
||
* tearsdown all directives instances generated during
|
||
* the process.
|
||
*
|
||
* We create unlink functions with only the necessary
|
||
* information to avoid retaining additional closures.
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {Array} dirs
|
||
* @param {Vue} [context]
|
||
* @param {Array} [contextDirs]
|
||
* @return {Function}
|
||
*/
|
||
|
||
function makeUnlinkFn(vm, dirs, context, contextDirs) {
|
||
function unlink(destroying) {
|
||
teardownDirs(vm, dirs, destroying);
|
||
if (context && contextDirs) {
|
||
teardownDirs(context, contextDirs);
|
||
}
|
||
}
|
||
// expose linked directives
|
||
unlink.dirs = dirs;
|
||
return unlink;
|
||
}
|
||
|
||
/**
|
||
* Teardown partial linked directives.
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {Array} dirs
|
||
* @param {Boolean} destroying
|
||
*/
|
||
|
||
function teardownDirs(vm, dirs, destroying) {
|
||
var i = dirs.length;
|
||
while (i--) {
|
||
dirs[i]._teardown();
|
||
if (process.env.NODE_ENV !== 'production' && !destroying) {
|
||
vm._directives.$remove(dirs[i]);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Compile link props on an instance.
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {Element} el
|
||
* @param {Object} props
|
||
* @param {Object} [scope]
|
||
* @return {Function}
|
||
*/
|
||
|
||
function compileAndLinkProps(vm, el, props, scope) {
|
||
var propsLinkFn = compileProps(el, props);
|
||
var propDirs = linkAndCapture(function () {
|
||
propsLinkFn(vm, scope);
|
||
}, vm);
|
||
return makeUnlinkFn(vm, propDirs);
|
||
}
|
||
|
||
/**
|
||
* Compile the root element of an instance.
|
||
*
|
||
* 1. attrs on context container (context scope)
|
||
* 2. attrs on the component template root node, if
|
||
* replace:true (child scope)
|
||
*
|
||
* If this is a fragment instance, we only need to compile 1.
|
||
*
|
||
* @param {Element} el
|
||
* @param {Object} options
|
||
* @param {Object} contextOptions
|
||
* @return {Function}
|
||
*/
|
||
|
||
function compileRoot(el, options, contextOptions) {
|
||
var containerAttrs = options._containerAttrs;
|
||
var replacerAttrs = options._replacerAttrs;
|
||
var contextLinkFn, replacerLinkFn;
|
||
|
||
// only need to compile other attributes for
|
||
// non-fragment instances
|
||
if (el.nodeType !== 11) {
|
||
// for components, container and replacer need to be
|
||
// compiled separately and linked in different scopes.
|
||
if (options._asComponent) {
|
||
// 2. container attributes
|
||
if (containerAttrs && contextOptions) {
|
||
contextLinkFn = compileDirectives(containerAttrs, contextOptions);
|
||
}
|
||
if (replacerAttrs) {
|
||
// 3. replacer attributes
|
||
replacerLinkFn = compileDirectives(replacerAttrs, options);
|
||
}
|
||
} else {
|
||
// non-component, just compile as a normal element.
|
||
replacerLinkFn = compileDirectives(el.attributes, options);
|
||
}
|
||
} else if (process.env.NODE_ENV !== 'production' && containerAttrs) {
|
||
// warn container directives for fragment instances
|
||
var names = containerAttrs.filter(function (attr) {
|
||
// allow vue-loader/vueify scoped css attributes
|
||
return attr.name.indexOf('_v-') < 0 &&
|
||
// allow event listeners
|
||
!onRE.test(attr.name) &&
|
||
// allow slots
|
||
attr.name !== 'slot';
|
||
}).map(function (attr) {
|
||
return '"' + attr.name + '"';
|
||
});
|
||
if (names.length) {
|
||
var plural = names.length > 1;
|
||
warn('Attribute' + (plural ? 's ' : ' ') + names.join(', ') + (plural ? ' are' : ' is') + ' ignored on component ' + '<' + options.el.tagName.toLowerCase() + '> because ' + 'the component is a fragment instance: ' + 'http://vuejs.org/guide/components.html#Fragment_Instance');
|
||
}
|
||
}
|
||
|
||
options._containerAttrs = options._replacerAttrs = null;
|
||
return function rootLinkFn(vm, el, scope) {
|
||
// link context scope dirs
|
||
var context = vm._context;
|
||
var contextDirs;
|
||
if (context && contextLinkFn) {
|
||
contextDirs = linkAndCapture(function () {
|
||
contextLinkFn(context, el, null, scope);
|
||
}, context);
|
||
}
|
||
|
||
// link self
|
||
var selfDirs = linkAndCapture(function () {
|
||
if (replacerLinkFn) replacerLinkFn(vm, el);
|
||
}, vm);
|
||
|
||
// return the unlink function that tearsdown context
|
||
// container directives.
|
||
return makeUnlinkFn(vm, selfDirs, context, contextDirs);
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Compile a node and return a nodeLinkFn based on the
|
||
* node type.
|
||
*
|
||
* @param {Node} node
|
||
* @param {Object} options
|
||
* @return {Function|null}
|
||
*/
|
||
|
||
function compileNode(node, options) {
|
||
var type = node.nodeType;
|
||
if (type === 1 && node.tagName !== 'SCRIPT') {
|
||
return compileElement(node, options);
|
||
} else if (type === 3 && node.data.trim()) {
|
||
return compileTextNode(node, options);
|
||
} else {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Compile an element and return a nodeLinkFn.
|
||
*
|
||
* @param {Element} el
|
||
* @param {Object} options
|
||
* @return {Function|null}
|
||
*/
|
||
|
||
function compileElement(el, options) {
|
||
// preprocess textareas.
|
||
// textarea treats its text content as the initial value.
|
||
// just bind it as an attr directive for value.
|
||
if (el.tagName === 'TEXTAREA') {
|
||
var tokens = parseText(el.value);
|
||
if (tokens) {
|
||
el.setAttribute(':value', tokensToExp(tokens));
|
||
el.value = '';
|
||
}
|
||
}
|
||
var linkFn;
|
||
var hasAttrs = el.hasAttributes();
|
||
// check terminal directives (for & if)
|
||
if (hasAttrs) {
|
||
linkFn = checkTerminalDirectives(el, options);
|
||
}
|
||
// check element directives
|
||
if (!linkFn) {
|
||
linkFn = checkElementDirectives(el, options);
|
||
}
|
||
// check component
|
||
if (!linkFn) {
|
||
linkFn = checkComponent(el, options);
|
||
}
|
||
// normal directives
|
||
if (!linkFn && hasAttrs) {
|
||
linkFn = compileDirectives(el.attributes, options);
|
||
}
|
||
return linkFn;
|
||
}
|
||
|
||
/**
|
||
* Compile a textNode and return a nodeLinkFn.
|
||
*
|
||
* @param {TextNode} node
|
||
* @param {Object} options
|
||
* @return {Function|null} textNodeLinkFn
|
||
*/
|
||
|
||
function compileTextNode(node, options) {
|
||
// skip marked text nodes
|
||
if (node._skip) {
|
||
return removeText;
|
||
}
|
||
|
||
var tokens = parseText(node.wholeText);
|
||
if (!tokens) {
|
||
return null;
|
||
}
|
||
|
||
// mark adjacent text nodes as skipped,
|
||
// because we are using node.wholeText to compile
|
||
// all adjacent text nodes together. This fixes
|
||
// issues in IE where sometimes it splits up a single
|
||
// text node into multiple ones.
|
||
var next = node.nextSibling;
|
||
while (next && next.nodeType === 3) {
|
||
next._skip = true;
|
||
next = next.nextSibling;
|
||
}
|
||
|
||
var frag = document.createDocumentFragment();
|
||
var el, token;
|
||
for (var i = 0, l = tokens.length; i < l; i++) {
|
||
token = tokens[i];
|
||
el = token.tag ? processTextToken(token, options) : document.createTextNode(token.value);
|
||
frag.appendChild(el);
|
||
}
|
||
return makeTextNodeLinkFn(tokens, frag, options);
|
||
}
|
||
|
||
/**
|
||
* Linker for an skipped text node.
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {Text} node
|
||
*/
|
||
|
||
function removeText(vm, node) {
|
||
remove(node);
|
||
}
|
||
|
||
/**
|
||
* Process a single text token.
|
||
*
|
||
* @param {Object} token
|
||
* @param {Object} options
|
||
* @return {Node}
|
||
*/
|
||
|
||
function processTextToken(token, options) {
|
||
var el;
|
||
if (token.oneTime) {
|
||
el = document.createTextNode(token.value);
|
||
} else {
|
||
if (token.html) {
|
||
el = document.createComment('v-html');
|
||
setTokenType('html');
|
||
} else {
|
||
// IE will clean up empty textNodes during
|
||
// frag.cloneNode(true), so we have to give it
|
||
// something here...
|
||
el = document.createTextNode(' ');
|
||
setTokenType('text');
|
||
}
|
||
}
|
||
function setTokenType(type) {
|
||
if (token.descriptor) return;
|
||
var parsed = parseDirective(token.value);
|
||
token.descriptor = {
|
||
name: type,
|
||
def: directives[type],
|
||
expression: parsed.expression,
|
||
filters: parsed.filters
|
||
};
|
||
}
|
||
return el;
|
||
}
|
||
|
||
/**
|
||
* Build a function that processes a textNode.
|
||
*
|
||
* @param {Array<Object>} tokens
|
||
* @param {DocumentFragment} frag
|
||
*/
|
||
|
||
function makeTextNodeLinkFn(tokens, frag) {
|
||
return function textNodeLinkFn(vm, el, host, scope) {
|
||
var fragClone = frag.cloneNode(true);
|
||
var childNodes = toArray(fragClone.childNodes);
|
||
var token, value, node;
|
||
for (var i = 0, l = tokens.length; i < l; i++) {
|
||
token = tokens[i];
|
||
value = token.value;
|
||
if (token.tag) {
|
||
node = childNodes[i];
|
||
if (token.oneTime) {
|
||
value = (scope || vm).$eval(value);
|
||
if (token.html) {
|
||
replace(node, parseTemplate(value, true));
|
||
} else {
|
||
node.data = value;
|
||
}
|
||
} else {
|
||
vm._bindDir(token.descriptor, node, host, scope);
|
||
}
|
||
}
|
||
}
|
||
replace(el, fragClone);
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Compile a node list and return a childLinkFn.
|
||
*
|
||
* @param {NodeList} nodeList
|
||
* @param {Object} options
|
||
* @return {Function|undefined}
|
||
*/
|
||
|
||
function compileNodeList(nodeList, options) {
|
||
var linkFns = [];
|
||
var nodeLinkFn, childLinkFn, node;
|
||
for (var i = 0, l = nodeList.length; i < l; i++) {
|
||
node = nodeList[i];
|
||
nodeLinkFn = compileNode(node, options);
|
||
childLinkFn = !(nodeLinkFn && nodeLinkFn.terminal) && node.tagName !== 'SCRIPT' && node.hasChildNodes() ? compileNodeList(node.childNodes, options) : null;
|
||
linkFns.push(nodeLinkFn, childLinkFn);
|
||
}
|
||
return linkFns.length ? makeChildLinkFn(linkFns) : null;
|
||
}
|
||
|
||
/**
|
||
* Make a child link function for a node's childNodes.
|
||
*
|
||
* @param {Array<Function>} linkFns
|
||
* @return {Function} childLinkFn
|
||
*/
|
||
|
||
function makeChildLinkFn(linkFns) {
|
||
return function childLinkFn(vm, nodes, host, scope, frag) {
|
||
var node, nodeLinkFn, childrenLinkFn;
|
||
for (var i = 0, n = 0, l = linkFns.length; i < l; n++) {
|
||
node = nodes[n];
|
||
nodeLinkFn = linkFns[i++];
|
||
childrenLinkFn = linkFns[i++];
|
||
// cache childNodes before linking parent, fix #657
|
||
var childNodes = toArray(node.childNodes);
|
||
if (nodeLinkFn) {
|
||
nodeLinkFn(vm, node, host, scope, frag);
|
||
}
|
||
if (childrenLinkFn) {
|
||
childrenLinkFn(vm, childNodes, host, scope, frag);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Check for element directives (custom elements that should
|
||
* be resovled as terminal directives).
|
||
*
|
||
* @param {Element} el
|
||
* @param {Object} options
|
||
*/
|
||
|
||
function checkElementDirectives(el, options) {
|
||
var tag = el.tagName.toLowerCase();
|
||
if (commonTagRE.test(tag)) {
|
||
return;
|
||
}
|
||
var def = resolveAsset(options, 'elementDirectives', tag);
|
||
if (def) {
|
||
return makeTerminalNodeLinkFn(el, tag, '', options, def);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Check if an element is a component. If yes, return
|
||
* a component link function.
|
||
*
|
||
* @param {Element} el
|
||
* @param {Object} options
|
||
* @return {Function|undefined}
|
||
*/
|
||
|
||
function checkComponent(el, options) {
|
||
var component = checkComponentAttr(el, options);
|
||
if (component) {
|
||
var ref = findRef(el);
|
||
var descriptor = {
|
||
name: 'component',
|
||
ref: ref,
|
||
expression: component.id,
|
||
def: internalDirectives.component,
|
||
modifiers: {
|
||
literal: !component.dynamic
|
||
}
|
||
};
|
||
var componentLinkFn = function componentLinkFn(vm, el, host, scope, frag) {
|
||
if (ref) {
|
||
defineReactive((scope || vm).$refs, ref, null);
|
||
}
|
||
vm._bindDir(descriptor, el, host, scope, frag);
|
||
};
|
||
componentLinkFn.terminal = true;
|
||
return componentLinkFn;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Check an element for terminal directives in fixed order.
|
||
* If it finds one, return a terminal link function.
|
||
*
|
||
* @param {Element} el
|
||
* @param {Object} options
|
||
* @return {Function} terminalLinkFn
|
||
*/
|
||
|
||
function checkTerminalDirectives(el, options) {
|
||
// skip v-pre
|
||
if (getAttr(el, 'v-pre') !== null) {
|
||
return skip;
|
||
}
|
||
// skip v-else block, but only if following v-if
|
||
if (el.hasAttribute('v-else')) {
|
||
var prev = el.previousElementSibling;
|
||
if (prev && prev.hasAttribute('v-if')) {
|
||
return skip;
|
||
}
|
||
}
|
||
var value, dirName;
|
||
for (var i = 0, l = terminalDirectives.length; i < l; i++) {
|
||
dirName = terminalDirectives[i];
|
||
value = el.getAttribute('v-' + dirName);
|
||
if (value != null) {
|
||
return makeTerminalNodeLinkFn(el, dirName, value, options);
|
||
}
|
||
}
|
||
}
|
||
|
||
function skip() {}
|
||
skip.terminal = true;
|
||
|
||
/**
|
||
* Build a node link function for a terminal directive.
|
||
* A terminal link function terminates the current
|
||
* compilation recursion and handles compilation of the
|
||
* subtree in the directive.
|
||
*
|
||
* @param {Element} el
|
||
* @param {String} dirName
|
||
* @param {String} value
|
||
* @param {Object} options
|
||
* @param {Object} [def]
|
||
* @return {Function} terminalLinkFn
|
||
*/
|
||
|
||
function makeTerminalNodeLinkFn(el, dirName, value, options, def) {
|
||
var parsed = parseDirective(value);
|
||
var descriptor = {
|
||
name: dirName,
|
||
expression: parsed.expression,
|
||
filters: parsed.filters,
|
||
raw: value,
|
||
// either an element directive, or if/for
|
||
// #2366 or custom terminal directive
|
||
def: def || resolveAsset(options, 'directives', dirName)
|
||
};
|
||
// check ref for v-for and router-view
|
||
if (dirName === 'for' || dirName === 'router-view') {
|
||
descriptor.ref = findRef(el);
|
||
}
|
||
var fn = function terminalNodeLinkFn(vm, el, host, scope, frag) {
|
||
if (descriptor.ref) {
|
||
defineReactive((scope || vm).$refs, descriptor.ref, null);
|
||
}
|
||
vm._bindDir(descriptor, el, host, scope, frag);
|
||
};
|
||
fn.terminal = true;
|
||
return fn;
|
||
}
|
||
|
||
/**
|
||
* Compile the directives on an element and return a linker.
|
||
*
|
||
* @param {Array|NamedNodeMap} attrs
|
||
* @param {Object} options
|
||
* @return {Function}
|
||
*/
|
||
|
||
function compileDirectives(attrs, options) {
|
||
var i = attrs.length;
|
||
var dirs = [];
|
||
var attr, name, value, rawName, rawValue, dirName, arg, modifiers, dirDef, tokens, matched;
|
||
while (i--) {
|
||
attr = attrs[i];
|
||
name = rawName = attr.name;
|
||
value = rawValue = attr.value;
|
||
tokens = parseText(value);
|
||
// reset arg
|
||
arg = null;
|
||
// check modifiers
|
||
modifiers = parseModifiers(name);
|
||
name = name.replace(modifierRE, '');
|
||
|
||
// attribute interpolations
|
||
if (tokens) {
|
||
value = tokensToExp(tokens);
|
||
arg = name;
|
||
pushDir('bind', directives.bind, tokens);
|
||
// warn against mixing mustaches with v-bind
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
if (name === 'class' && Array.prototype.some.call(attrs, function (attr) {
|
||
return attr.name === ':class' || attr.name === 'v-bind:class';
|
||
})) {
|
||
warn('class="' + rawValue + '": Do not mix mustache interpolation ' + 'and v-bind for "class" on the same element. Use one or the other.');
|
||
}
|
||
}
|
||
} else
|
||
|
||
// special attribute: transition
|
||
if (transitionRE.test(name)) {
|
||
modifiers.literal = !bindRE.test(name);
|
||
pushDir('transition', internalDirectives.transition);
|
||
} else
|
||
|
||
// event handlers
|
||
if (onRE.test(name)) {
|
||
arg = name.replace(onRE, '');
|
||
pushDir('on', directives.on);
|
||
} else
|
||
|
||
// attribute bindings
|
||
if (bindRE.test(name)) {
|
||
dirName = name.replace(bindRE, '');
|
||
if (dirName === 'style' || dirName === 'class') {
|
||
pushDir(dirName, internalDirectives[dirName]);
|
||
} else {
|
||
arg = dirName;
|
||
pushDir('bind', directives.bind);
|
||
}
|
||
} else
|
||
|
||
// normal directives
|
||
if (matched = name.match(dirAttrRE)) {
|
||
dirName = matched[1];
|
||
arg = matched[2];
|
||
|
||
// skip v-else (when used with v-show)
|
||
if (dirName === 'else') {
|
||
continue;
|
||
}
|
||
|
||
dirDef = resolveAsset(options, 'directives', dirName);
|
||
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
assertAsset(dirDef, 'directive', dirName);
|
||
}
|
||
|
||
if (dirDef) {
|
||
pushDir(dirName, dirDef);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Push a directive.
|
||
*
|
||
* @param {String} dirName
|
||
* @param {Object|Function} def
|
||
* @param {Array} [interpTokens]
|
||
*/
|
||
|
||
function pushDir(dirName, def, interpTokens) {
|
||
var hasOneTimeToken = interpTokens && hasOneTime(interpTokens);
|
||
var parsed = !hasOneTimeToken && parseDirective(value);
|
||
dirs.push({
|
||
name: dirName,
|
||
attr: rawName,
|
||
raw: rawValue,
|
||
def: def,
|
||
arg: arg,
|
||
modifiers: modifiers,
|
||
// conversion from interpolation strings with one-time token
|
||
// to expression is differed until directive bind time so that we
|
||
// have access to the actual vm context for one-time bindings.
|
||
expression: parsed && parsed.expression,
|
||
filters: parsed && parsed.filters,
|
||
interp: interpTokens,
|
||
hasOneTime: hasOneTimeToken
|
||
});
|
||
}
|
||
|
||
if (dirs.length) {
|
||
return makeNodeLinkFn(dirs);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Parse modifiers from directive attribute name.
|
||
*
|
||
* @param {String} name
|
||
* @return {Object}
|
||
*/
|
||
|
||
function parseModifiers(name) {
|
||
var res = Object.create(null);
|
||
var match = name.match(modifierRE);
|
||
if (match) {
|
||
var i = match.length;
|
||
while (i--) {
|
||
res[match[i].slice(1)] = true;
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
|
||
/**
|
||
* Build a link function for all directives on a single node.
|
||
*
|
||
* @param {Array} directives
|
||
* @return {Function} directivesLinkFn
|
||
*/
|
||
|
||
function makeNodeLinkFn(directives) {
|
||
return function nodeLinkFn(vm, el, host, scope, frag) {
|
||
// reverse apply because it's sorted low to high
|
||
var i = directives.length;
|
||
while (i--) {
|
||
vm._bindDir(directives[i], el, host, scope, frag);
|
||
}
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Check if an interpolation string contains one-time tokens.
|
||
*
|
||
* @param {Array} tokens
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
function hasOneTime(tokens) {
|
||
var i = tokens.length;
|
||
while (i--) {
|
||
if (tokens[i].oneTime) return true;
|
||
}
|
||
}
|
||
|
||
var specialCharRE = /[^\w\-:\.]/;
|
||
|
||
/**
|
||
* Process an element or a DocumentFragment based on a
|
||
* instance option object. This allows us to transclude
|
||
* a template node/fragment before the instance is created,
|
||
* so the processed fragment can then be cloned and reused
|
||
* in v-for.
|
||
*
|
||
* @param {Element} el
|
||
* @param {Object} options
|
||
* @return {Element|DocumentFragment}
|
||
*/
|
||
|
||
function transclude(el, options) {
|
||
// extract container attributes to pass them down
|
||
// to compiler, because they need to be compiled in
|
||
// parent scope. we are mutating the options object here
|
||
// assuming the same object will be used for compile
|
||
// right after this.
|
||
if (options) {
|
||
options._containerAttrs = extractAttrs(el);
|
||
}
|
||
// for template tags, what we want is its content as
|
||
// a documentFragment (for fragment instances)
|
||
if (isTemplate(el)) {
|
||
el = parseTemplate(el);
|
||
}
|
||
if (options) {
|
||
if (options._asComponent && !options.template) {
|
||
options.template = '<slot></slot>';
|
||
}
|
||
if (options.template) {
|
||
options._content = extractContent(el);
|
||
el = transcludeTemplate(el, options);
|
||
}
|
||
}
|
||
if (isFragment(el)) {
|
||
// anchors for fragment instance
|
||
// passing in `persist: true` to avoid them being
|
||
// discarded by IE during template cloning
|
||
prepend(createAnchor('v-start', true), el);
|
||
el.appendChild(createAnchor('v-end', true));
|
||
}
|
||
return el;
|
||
}
|
||
|
||
/**
|
||
* Process the template option.
|
||
* If the replace option is true this will swap the $el.
|
||
*
|
||
* @param {Element} el
|
||
* @param {Object} options
|
||
* @return {Element|DocumentFragment}
|
||
*/
|
||
|
||
function transcludeTemplate(el, options) {
|
||
var template = options.template;
|
||
var frag = parseTemplate(template, true);
|
||
if (frag) {
|
||
var replacer = frag.firstChild;
|
||
var tag = replacer.tagName && replacer.tagName.toLowerCase();
|
||
if (options.replace) {
|
||
/* istanbul ignore if */
|
||
if (el === document.body) {
|
||
process.env.NODE_ENV !== 'production' && warn('You are mounting an instance with a template to ' + '<body>. This will replace <body> entirely. You ' + 'should probably use `replace: false` here.');
|
||
}
|
||
// there are many cases where the instance must
|
||
// become a fragment instance: basically anything that
|
||
// can create more than 1 root nodes.
|
||
if (
|
||
// multi-children template
|
||
frag.childNodes.length > 1 ||
|
||
// non-element template
|
||
replacer.nodeType !== 1 ||
|
||
// single nested component
|
||
tag === 'component' || resolveAsset(options, 'components', tag) || hasBindAttr(replacer, 'is') ||
|
||
// element directive
|
||
resolveAsset(options, 'elementDirectives', tag) ||
|
||
// for block
|
||
replacer.hasAttribute('v-for') ||
|
||
// if block
|
||
replacer.hasAttribute('v-if')) {
|
||
return frag;
|
||
} else {
|
||
options._replacerAttrs = extractAttrs(replacer);
|
||
mergeAttrs(el, replacer);
|
||
return replacer;
|
||
}
|
||
} else {
|
||
el.appendChild(frag);
|
||
return el;
|
||
}
|
||
} else {
|
||
process.env.NODE_ENV !== 'production' && warn('Invalid template option: ' + template);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Helper to extract a component container's attributes
|
||
* into a plain object array.
|
||
*
|
||
* @param {Element} el
|
||
* @return {Array}
|
||
*/
|
||
|
||
function extractAttrs(el) {
|
||
if (el.nodeType === 1 && el.hasAttributes()) {
|
||
return toArray(el.attributes);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Merge the attributes of two elements, and make sure
|
||
* the class names are merged properly.
|
||
*
|
||
* @param {Element} from
|
||
* @param {Element} to
|
||
*/
|
||
|
||
function mergeAttrs(from, to) {
|
||
var attrs = from.attributes;
|
||
var i = attrs.length;
|
||
var name, value;
|
||
while (i--) {
|
||
name = attrs[i].name;
|
||
value = attrs[i].value;
|
||
if (!to.hasAttribute(name) && !specialCharRE.test(name)) {
|
||
to.setAttribute(name, value);
|
||
} else if (name === 'class' && !parseText(value)) {
|
||
value.split(/\s+/).forEach(function (cls) {
|
||
addClass(to, cls);
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Scan and determine slot content distribution.
|
||
* We do this during transclusion instead at compile time so that
|
||
* the distribution is decoupled from the compilation order of
|
||
* the slots.
|
||
*
|
||
* @param {Element|DocumentFragment} template
|
||
* @param {Element} content
|
||
* @param {Vue} vm
|
||
*/
|
||
|
||
function scanSlots(template, content, vm) {
|
||
if (!content) {
|
||
return;
|
||
}
|
||
var contents = vm._slotContents = {};
|
||
var slots = template.querySelectorAll('slot');
|
||
if (slots.length) {
|
||
var hasDefault, slot, name;
|
||
for (var i = 0, l = slots.length; i < l; i++) {
|
||
slot = slots[i];
|
||
/* eslint-disable no-cond-assign */
|
||
if (name = slot.getAttribute('name')) {
|
||
select(slot, name);
|
||
} else if (process.env.NODE_ENV !== 'production' && (name = getBindAttr(slot, 'name'))) {
|
||
warn('<slot :name="' + name + '">: slot names cannot be dynamic.');
|
||
} else {
|
||
// default slot
|
||
hasDefault = true;
|
||
}
|
||
/* eslint-enable no-cond-assign */
|
||
}
|
||
if (hasDefault) {
|
||
contents['default'] = extractFragment(content.childNodes, content);
|
||
}
|
||
}
|
||
|
||
function select(slot, name) {
|
||
// named slot
|
||
var selector = '[slot="' + name + '"]';
|
||
var nodes = content.querySelectorAll(selector);
|
||
if (nodes.length) {
|
||
contents[name] = extractFragment(nodes, content);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Extract qualified content nodes from a node list.
|
||
*
|
||
* @param {NodeList} nodes
|
||
* @param {Element} parent
|
||
* @return {DocumentFragment}
|
||
*/
|
||
|
||
function extractFragment(nodes, parent) {
|
||
var frag = document.createDocumentFragment();
|
||
nodes = toArray(nodes);
|
||
for (var i = 0, l = nodes.length; i < l; i++) {
|
||
var node = nodes[i];
|
||
if (node.parentNode === parent) {
|
||
if (isTemplate(node) && !node.hasAttribute('v-if') && !node.hasAttribute('v-for')) {
|
||
parent.removeChild(node);
|
||
node = parseTemplate(node);
|
||
}
|
||
frag.appendChild(node);
|
||
}
|
||
}
|
||
return frag;
|
||
}
|
||
|
||
|
||
|
||
var compiler = Object.freeze({
|
||
compile: compile,
|
||
compileAndLinkProps: compileAndLinkProps,
|
||
compileRoot: compileRoot,
|
||
terminalDirectives: terminalDirectives,
|
||
transclude: transclude,
|
||
scanSlots: scanSlots
|
||
});
|
||
|
||
function stateMixin (Vue) {
|
||
/**
|
||
* Accessor for `$data` property, since setting $data
|
||
* requires observing the new object and updating
|
||
* proxied properties.
|
||
*/
|
||
|
||
Object.defineProperty(Vue.prototype, '$data', {
|
||
get: function get() {
|
||
return this._data;
|
||
},
|
||
set: function set(newData) {
|
||
if (newData !== this._data) {
|
||
this._setData(newData);
|
||
}
|
||
}
|
||
});
|
||
|
||
/**
|
||
* Setup the scope of an instance, which contains:
|
||
* - observed data
|
||
* - computed properties
|
||
* - user methods
|
||
* - meta properties
|
||
*/
|
||
|
||
Vue.prototype._initState = function () {
|
||
this._initProps();
|
||
this._initMeta();
|
||
this._initMethods();
|
||
this._initData();
|
||
this._initComputed();
|
||
};
|
||
|
||
/**
|
||
* Initialize props.
|
||
*/
|
||
|
||
Vue.prototype._initProps = function () {
|
||
var options = this.$options;
|
||
var el = options.el;
|
||
var props = options.props;
|
||
if (props && !el) {
|
||
process.env.NODE_ENV !== 'production' && warn('Props will not be compiled if no `el` option is ' + 'provided at instantiation.');
|
||
}
|
||
// make sure to convert string selectors into element now
|
||
el = options.el = query(el);
|
||
this._propsUnlinkFn = el && el.nodeType === 1 && props
|
||
// props must be linked in proper scope if inside v-for
|
||
? compileAndLinkProps(this, el, props, this._scope) : null;
|
||
};
|
||
|
||
/**
|
||
* Initialize the data.
|
||
*/
|
||
|
||
Vue.prototype._initData = function () {
|
||
var propsData = this._data;
|
||
var optionsDataFn = this.$options.data;
|
||
var optionsData = optionsDataFn && optionsDataFn();
|
||
var runtimeData;
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
runtimeData = (typeof this._runtimeData === 'function' ? this._runtimeData() : this._runtimeData) || {};
|
||
this._runtimeData = null;
|
||
}
|
||
if (optionsData) {
|
||
this._data = optionsData;
|
||
for (var prop in propsData) {
|
||
if (process.env.NODE_ENV !== 'production' && hasOwn(optionsData, prop) && !hasOwn(runtimeData, prop)) {
|
||
warn('Data field "' + prop + '" is already defined ' + 'as a prop. Use prop default value instead.');
|
||
}
|
||
if (this._props[prop].raw !== null || !hasOwn(optionsData, prop)) {
|
||
set(optionsData, prop, propsData[prop]);
|
||
}
|
||
}
|
||
}
|
||
var data = this._data;
|
||
// proxy data on instance
|
||
var keys = Object.keys(data);
|
||
var i, key;
|
||
i = keys.length;
|
||
while (i--) {
|
||
key = keys[i];
|
||
this._proxy(key);
|
||
}
|
||
// observe data
|
||
observe(data, this);
|
||
};
|
||
|
||
/**
|
||
* Swap the instance's $data. Called in $data's setter.
|
||
*
|
||
* @param {Object} newData
|
||
*/
|
||
|
||
Vue.prototype._setData = function (newData) {
|
||
newData = newData || {};
|
||
var oldData = this._data;
|
||
this._data = newData;
|
||
var keys, key, i;
|
||
// unproxy keys not present in new data
|
||
keys = Object.keys(oldData);
|
||
i = keys.length;
|
||
while (i--) {
|
||
key = keys[i];
|
||
if (!(key in newData)) {
|
||
this._unproxy(key);
|
||
}
|
||
}
|
||
// proxy keys not already proxied,
|
||
// and trigger change for changed values
|
||
keys = Object.keys(newData);
|
||
i = keys.length;
|
||
while (i--) {
|
||
key = keys[i];
|
||
if (!hasOwn(this, key)) {
|
||
// new property
|
||
this._proxy(key);
|
||
}
|
||
}
|
||
oldData.__ob__.removeVm(this);
|
||
observe(newData, this);
|
||
this._digest();
|
||
};
|
||
|
||
/**
|
||
* Proxy a property, so that
|
||
* vm.prop === vm._data.prop
|
||
*
|
||
* @param {String} key
|
||
*/
|
||
|
||
Vue.prototype._proxy = function (key) {
|
||
if (!isReserved(key)) {
|
||
// need to store ref to self here
|
||
// because these getter/setters might
|
||
// be called by child scopes via
|
||
// prototype inheritance.
|
||
var self = this;
|
||
Object.defineProperty(self, key, {
|
||
configurable: true,
|
||
enumerable: true,
|
||
get: function proxyGetter() {
|
||
return self._data[key];
|
||
},
|
||
set: function proxySetter(val) {
|
||
self._data[key] = val;
|
||
}
|
||
});
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Unproxy a property.
|
||
*
|
||
* @param {String} key
|
||
*/
|
||
|
||
Vue.prototype._unproxy = function (key) {
|
||
if (!isReserved(key)) {
|
||
delete this[key];
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Force update on every watcher in scope.
|
||
*/
|
||
|
||
Vue.prototype._digest = function () {
|
||
for (var i = 0, l = this._watchers.length; i < l; i++) {
|
||
this._watchers[i].update(true); // shallow updates
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Setup computed properties. They are essentially
|
||
* special getter/setters
|
||
*/
|
||
|
||
function noop() {}
|
||
Vue.prototype._initComputed = function () {
|
||
var computed = this.$options.computed;
|
||
if (computed) {
|
||
for (var key in computed) {
|
||
var userDef = computed[key];
|
||
var def = {
|
||
enumerable: true,
|
||
configurable: true
|
||
};
|
||
if (typeof userDef === 'function') {
|
||
def.get = makeComputedGetter(userDef, this);
|
||
def.set = noop;
|
||
} else {
|
||
def.get = userDef.get ? userDef.cache !== false ? makeComputedGetter(userDef.get, this) : bind(userDef.get, this) : noop;
|
||
def.set = userDef.set ? bind(userDef.set, this) : noop;
|
||
}
|
||
Object.defineProperty(this, key, def);
|
||
}
|
||
}
|
||
};
|
||
|
||
function makeComputedGetter(getter, owner) {
|
||
var watcher = new Watcher(owner, getter, null, {
|
||
lazy: true
|
||
});
|
||
return function computedGetter() {
|
||
if (watcher.dirty) {
|
||
watcher.evaluate();
|
||
}
|
||
if (Dep.target) {
|
||
watcher.depend();
|
||
}
|
||
return watcher.value;
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Setup instance methods. Methods must be bound to the
|
||
* instance since they might be passed down as a prop to
|
||
* child components.
|
||
*/
|
||
|
||
Vue.prototype._initMethods = function () {
|
||
var methods = this.$options.methods;
|
||
if (methods) {
|
||
for (var key in methods) {
|
||
this[key] = bind(methods[key], this);
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Initialize meta information like $index, $key & $value.
|
||
*/
|
||
|
||
Vue.prototype._initMeta = function () {
|
||
var metas = this.$options._meta;
|
||
if (metas) {
|
||
for (var key in metas) {
|
||
defineReactive(this, key, metas[key]);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
var eventRE = /^v-on:|^@/;
|
||
|
||
function eventsMixin (Vue) {
|
||
/**
|
||
* Setup the instance's option events & watchers.
|
||
* If the value is a string, we pull it from the
|
||
* instance's methods by name.
|
||
*/
|
||
|
||
Vue.prototype._initEvents = function () {
|
||
var options = this.$options;
|
||
if (options._asComponent) {
|
||
registerComponentEvents(this, options.el);
|
||
}
|
||
registerCallbacks(this, '$on', options.events);
|
||
registerCallbacks(this, '$watch', options.watch);
|
||
};
|
||
|
||
/**
|
||
* Register v-on events on a child component
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {Element} el
|
||
*/
|
||
|
||
function registerComponentEvents(vm, el) {
|
||
var attrs = el.attributes;
|
||
var name, handler;
|
||
for (var i = 0, l = attrs.length; i < l; i++) {
|
||
name = attrs[i].name;
|
||
if (eventRE.test(name)) {
|
||
name = name.replace(eventRE, '');
|
||
handler = (vm._scope || vm._context).$eval(attrs[i].value, true);
|
||
if (typeof handler === 'function') {
|
||
handler._fromParent = true;
|
||
vm.$on(name.replace(eventRE), handler);
|
||
} else if (process.env.NODE_ENV !== 'production') {
|
||
warn('v-on:' + name + '="' + attrs[i].value + '"' + (vm.$options.name ? ' on component <' + vm.$options.name + '>' : '') + ' expects a function value, got ' + handler);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Register callbacks for option events and watchers.
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {String} action
|
||
* @param {Object} hash
|
||
*/
|
||
|
||
function registerCallbacks(vm, action, hash) {
|
||
if (!hash) return;
|
||
var handlers, key, i, j;
|
||
for (key in hash) {
|
||
handlers = hash[key];
|
||
if (isArray(handlers)) {
|
||
for (i = 0, j = handlers.length; i < j; i++) {
|
||
register(vm, action, key, handlers[i]);
|
||
}
|
||
} else {
|
||
register(vm, action, key, handlers);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Helper to register an event/watch callback.
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {String} action
|
||
* @param {String} key
|
||
* @param {Function|String|Object} handler
|
||
* @param {Object} [options]
|
||
*/
|
||
|
||
function register(vm, action, key, handler, options) {
|
||
var type = typeof handler;
|
||
if (type === 'function') {
|
||
vm[action](key, handler, options);
|
||
} else if (type === 'string') {
|
||
var methods = vm.$options.methods;
|
||
var method = methods && methods[handler];
|
||
if (method) {
|
||
vm[action](key, method, options);
|
||
} else {
|
||
process.env.NODE_ENV !== 'production' && warn('Unknown method: "' + handler + '" when ' + 'registering callback for ' + action + ': "' + key + '".');
|
||
}
|
||
} else if (handler && type === 'object') {
|
||
register(vm, action, key, handler.handler, handler);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Setup recursive attached/detached calls
|
||
*/
|
||
|
||
Vue.prototype._initDOMHooks = function () {
|
||
this.$on('hook:attached', onAttached);
|
||
this.$on('hook:detached', onDetached);
|
||
};
|
||
|
||
/**
|
||
* Callback to recursively call attached hook on children
|
||
*/
|
||
|
||
function onAttached() {
|
||
if (!this._isAttached) {
|
||
this._isAttached = true;
|
||
this.$children.forEach(callAttach);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Iterator to call attached hook
|
||
*
|
||
* @param {Vue} child
|
||
*/
|
||
|
||
function callAttach(child) {
|
||
if (!child._isAttached && inDoc(child.$el)) {
|
||
child._callHook('attached');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Callback to recursively call detached hook on children
|
||
*/
|
||
|
||
function onDetached() {
|
||
if (this._isAttached) {
|
||
this._isAttached = false;
|
||
this.$children.forEach(callDetach);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Iterator to call detached hook
|
||
*
|
||
* @param {Vue} child
|
||
*/
|
||
|
||
function callDetach(child) {
|
||
if (child._isAttached && !inDoc(child.$el)) {
|
||
child._callHook('detached');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Trigger all handlers for a hook
|
||
*
|
||
* @param {String} hook
|
||
*/
|
||
|
||
Vue.prototype._callHook = function (hook) {
|
||
this.$emit('pre-hook:' + hook);
|
||
var handlers = this.$options[hook];
|
||
if (handlers) {
|
||
for (var i = 0, j = handlers.length; i < j; i++) {
|
||
handlers[i].call(this);
|
||
}
|
||
}
|
||
this.$emit('hook:' + hook);
|
||
};
|
||
}
|
||
|
||
function noop() {}
|
||
|
||
/**
|
||
* A directive links a DOM element with a piece of data,
|
||
* which is the result of evaluating an expression.
|
||
* It registers a watcher with the expression and calls
|
||
* the DOM update function when a change is triggered.
|
||
*
|
||
* @param {String} name
|
||
* @param {Node} el
|
||
* @param {Vue} vm
|
||
* @param {Object} descriptor
|
||
* - {String} name
|
||
* - {Object} def
|
||
* - {String} expression
|
||
* - {Array<Object>} [filters]
|
||
* - {Boolean} literal
|
||
* - {String} attr
|
||
* - {String} raw
|
||
* @param {Object} def - directive definition object
|
||
* @param {Vue} [host] - transclusion host component
|
||
* @param {Object} [scope] - v-for scope
|
||
* @param {Fragment} [frag] - owner fragment
|
||
* @constructor
|
||
*/
|
||
function Directive(descriptor, vm, el, host, scope, frag) {
|
||
this.vm = vm;
|
||
this.el = el;
|
||
// copy descriptor properties
|
||
this.descriptor = descriptor;
|
||
this.name = descriptor.name;
|
||
this.expression = descriptor.expression;
|
||
this.arg = descriptor.arg;
|
||
this.modifiers = descriptor.modifiers;
|
||
this.filters = descriptor.filters;
|
||
this.literal = this.modifiers && this.modifiers.literal;
|
||
// private
|
||
this._locked = false;
|
||
this._bound = false;
|
||
this._listeners = null;
|
||
// link context
|
||
this._host = host;
|
||
this._scope = scope;
|
||
this._frag = frag;
|
||
// store directives on node in dev mode
|
||
if (process.env.NODE_ENV !== 'production' && this.el) {
|
||
this.el._vue_directives = this.el._vue_directives || [];
|
||
this.el._vue_directives.push(this);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Initialize the directive, mixin definition properties,
|
||
* setup the watcher, call definition bind() and update()
|
||
* if present.
|
||
*
|
||
* @param {Object} def
|
||
*/
|
||
|
||
Directive.prototype._bind = function () {
|
||
var name = this.name;
|
||
var descriptor = this.descriptor;
|
||
|
||
// remove attribute
|
||
if ((name !== 'cloak' || this.vm._isCompiled) && this.el && this.el.removeAttribute) {
|
||
var attr = descriptor.attr || 'v-' + name;
|
||
this.el.removeAttribute(attr);
|
||
}
|
||
|
||
// copy def properties
|
||
var def = descriptor.def;
|
||
if (typeof def === 'function') {
|
||
this.update = def;
|
||
} else {
|
||
extend(this, def);
|
||
}
|
||
|
||
// setup directive params
|
||
this._setupParams();
|
||
|
||
// initial bind
|
||
if (this.bind) {
|
||
this.bind();
|
||
}
|
||
this._bound = true;
|
||
|
||
if (this.literal) {
|
||
this.update && this.update(descriptor.raw);
|
||
} else if ((this.expression || this.modifiers) && (this.update || this.twoWay) && !this._checkStatement()) {
|
||
// wrapped updater for context
|
||
var dir = this;
|
||
if (this.update) {
|
||
this._update = function (val, oldVal) {
|
||
if (!dir._locked) {
|
||
dir.update(val, oldVal);
|
||
}
|
||
};
|
||
} else {
|
||
this._update = noop;
|
||
}
|
||
var preProcess = this._preProcess ? bind(this._preProcess, this) : null;
|
||
var postProcess = this._postProcess ? bind(this._postProcess, this) : null;
|
||
var watcher = this._watcher = new Watcher(this.vm, this.expression, this._update, // callback
|
||
{
|
||
filters: this.filters,
|
||
twoWay: this.twoWay,
|
||
deep: this.deep,
|
||
preProcess: preProcess,
|
||
postProcess: postProcess,
|
||
scope: this._scope
|
||
});
|
||
// v-model with inital inline value need to sync back to
|
||
// model instead of update to DOM on init. They would
|
||
// set the afterBind hook to indicate that.
|
||
if (this.afterBind) {
|
||
this.afterBind();
|
||
} else if (this.update) {
|
||
this.update(watcher.value);
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Setup all param attributes, e.g. track-by,
|
||
* transition-mode, etc...
|
||
*/
|
||
|
||
Directive.prototype._setupParams = function () {
|
||
if (!this.params) {
|
||
return;
|
||
}
|
||
var params = this.params;
|
||
// swap the params array with a fresh object.
|
||
this.params = Object.create(null);
|
||
var i = params.length;
|
||
var key, val, mappedKey;
|
||
while (i--) {
|
||
key = params[i];
|
||
mappedKey = camelize(key);
|
||
val = getBindAttr(this.el, key);
|
||
if (val != null) {
|
||
// dynamic
|
||
this._setupParamWatcher(mappedKey, val);
|
||
} else {
|
||
// static
|
||
val = getAttr(this.el, key);
|
||
if (val != null) {
|
||
this.params[mappedKey] = val === '' ? true : val;
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Setup a watcher for a dynamic param.
|
||
*
|
||
* @param {String} key
|
||
* @param {String} expression
|
||
*/
|
||
|
||
Directive.prototype._setupParamWatcher = function (key, expression) {
|
||
var self = this;
|
||
var called = false;
|
||
var unwatch = (this._scope || this.vm).$watch(expression, function (val, oldVal) {
|
||
self.params[key] = val;
|
||
// since we are in immediate mode,
|
||
// only call the param change callbacks if this is not the first update.
|
||
if (called) {
|
||
var cb = self.paramWatchers && self.paramWatchers[key];
|
||
if (cb) {
|
||
cb.call(self, val, oldVal);
|
||
}
|
||
} else {
|
||
called = true;
|
||
}
|
||
}, {
|
||
immediate: true,
|
||
user: false
|
||
});(this._paramUnwatchFns || (this._paramUnwatchFns = [])).push(unwatch);
|
||
};
|
||
|
||
/**
|
||
* Check if the directive is a function caller
|
||
* and if the expression is a callable one. If both true,
|
||
* we wrap up the expression and use it as the event
|
||
* handler.
|
||
*
|
||
* e.g. on-click="a++"
|
||
*
|
||
* @return {Boolean}
|
||
*/
|
||
|
||
Directive.prototype._checkStatement = function () {
|
||
var expression = this.expression;
|
||
if (expression && this.acceptStatement && !isSimplePath(expression)) {
|
||
var fn = parseExpression(expression).get;
|
||
var scope = this._scope || this.vm;
|
||
var handler = function handler(e) {
|
||
scope.$event = e;
|
||
fn.call(scope, scope);
|
||
scope.$event = null;
|
||
};
|
||
if (this.filters) {
|
||
handler = scope._applyFilters(handler, null, this.filters);
|
||
}
|
||
this.update(handler);
|
||
return true;
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Set the corresponding value with the setter.
|
||
* This should only be used in two-way directives
|
||
* e.g. v-model.
|
||
*
|
||
* @param {*} value
|
||
* @public
|
||
*/
|
||
|
||
Directive.prototype.set = function (value) {
|
||
/* istanbul ignore else */
|
||
if (this.twoWay) {
|
||
this._withLock(function () {
|
||
this._watcher.set(value);
|
||
});
|
||
} else if (process.env.NODE_ENV !== 'production') {
|
||
warn('Directive.set() can only be used inside twoWay' + 'directives.');
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Execute a function while preventing that function from
|
||
* triggering updates on this directive instance.
|
||
*
|
||
* @param {Function} fn
|
||
*/
|
||
|
||
Directive.prototype._withLock = function (fn) {
|
||
var self = this;
|
||
self._locked = true;
|
||
fn.call(self);
|
||
nextTick(function () {
|
||
self._locked = false;
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Convenience method that attaches a DOM event listener
|
||
* to the directive element and autometically tears it down
|
||
* during unbind.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} handler
|
||
* @param {Boolean} [useCapture]
|
||
*/
|
||
|
||
Directive.prototype.on = function (event, handler, useCapture) {
|
||
on(this.el, event, handler, useCapture);(this._listeners || (this._listeners = [])).push([event, handler]);
|
||
};
|
||
|
||
/**
|
||
* Teardown the watcher and call unbind.
|
||
*/
|
||
|
||
Directive.prototype._teardown = function () {
|
||
if (this._bound) {
|
||
this._bound = false;
|
||
if (this.unbind) {
|
||
this.unbind();
|
||
}
|
||
if (this._watcher) {
|
||
this._watcher.teardown();
|
||
}
|
||
var listeners = this._listeners;
|
||
var i;
|
||
if (listeners) {
|
||
i = listeners.length;
|
||
while (i--) {
|
||
off(this.el, listeners[i][0], listeners[i][1]);
|
||
}
|
||
}
|
||
var unwatchFns = this._paramUnwatchFns;
|
||
if (unwatchFns) {
|
||
i = unwatchFns.length;
|
||
while (i--) {
|
||
unwatchFns[i]();
|
||
}
|
||
}
|
||
if (process.env.NODE_ENV !== 'production' && this.el) {
|
||
this.el._vue_directives.$remove(this);
|
||
}
|
||
this.vm = this.el = this._watcher = this._listeners = null;
|
||
}
|
||
};
|
||
|
||
function lifecycleMixin (Vue) {
|
||
/**
|
||
* Update v-ref for component.
|
||
*
|
||
* @param {Boolean} remove
|
||
*/
|
||
|
||
Vue.prototype._updateRef = function (remove) {
|
||
var ref = this.$options._ref;
|
||
if (ref) {
|
||
var refs = (this._scope || this._context).$refs;
|
||
if (remove) {
|
||
if (refs[ref] === this) {
|
||
refs[ref] = null;
|
||
}
|
||
} else {
|
||
refs[ref] = this;
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Transclude, compile and link element.
|
||
*
|
||
* If a pre-compiled linker is available, that means the
|
||
* passed in element will be pre-transcluded and compiled
|
||
* as well - all we need to do is to call the linker.
|
||
*
|
||
* Otherwise we need to call transclude/compile/link here.
|
||
*
|
||
* @param {Element} el
|
||
*/
|
||
|
||
Vue.prototype._compile = function (el) {
|
||
var options = this.$options;
|
||
|
||
// transclude and init element
|
||
// transclude can potentially replace original
|
||
// so we need to keep reference; this step also injects
|
||
// the template and caches the original attributes
|
||
// on the container node and replacer node.
|
||
var original = el;
|
||
el = transclude(el, options);
|
||
this._initElement(el);
|
||
|
||
// handle v-pre on root node (#2026)
|
||
if (el.nodeType === 1 && getAttr(el, 'v-pre') !== null) {
|
||
return;
|
||
}
|
||
|
||
// root is always compiled per-instance, because
|
||
// container attrs and props can be different every time.
|
||
var contextOptions = this._context && this._context.$options;
|
||
var rootLinker = compileRoot(el, options, contextOptions);
|
||
|
||
// scan for slot distribution before compiling the content
|
||
// so that it's decoupeld from slot/directive compilation order
|
||
scanSlots(el, options._content, this);
|
||
|
||
// compile and link the rest
|
||
var contentLinkFn;
|
||
var ctor = this.constructor;
|
||
// component compilation can be cached
|
||
// as long as it's not using inline-template
|
||
if (options._linkerCachable) {
|
||
contentLinkFn = ctor.linker;
|
||
if (!contentLinkFn) {
|
||
contentLinkFn = ctor.linker = compile(el, options);
|
||
}
|
||
}
|
||
|
||
// link phase
|
||
// make sure to link root with prop scope!
|
||
var rootUnlinkFn = rootLinker(this, el, this._scope);
|
||
var contentUnlinkFn = contentLinkFn ? contentLinkFn(this, el) : compile(el, options)(this, el);
|
||
|
||
// register composite unlink function
|
||
// to be called during instance destruction
|
||
this._unlinkFn = function () {
|
||
rootUnlinkFn();
|
||
// passing destroying: true to avoid searching and
|
||
// splicing the directives
|
||
contentUnlinkFn(true);
|
||
};
|
||
|
||
// finally replace original
|
||
if (options.replace) {
|
||
replace(original, el);
|
||
}
|
||
|
||
this._isCompiled = true;
|
||
this._callHook('compiled');
|
||
};
|
||
|
||
/**
|
||
* Initialize instance element. Called in the public
|
||
* $mount() method.
|
||
*
|
||
* @param {Element} el
|
||
*/
|
||
|
||
Vue.prototype._initElement = function (el) {
|
||
if (isFragment(el)) {
|
||
this._isFragment = true;
|
||
this.$el = this._fragmentStart = el.firstChild;
|
||
this._fragmentEnd = el.lastChild;
|
||
// set persisted text anchors to empty
|
||
if (this._fragmentStart.nodeType === 3) {
|
||
this._fragmentStart.data = this._fragmentEnd.data = '';
|
||
}
|
||
this._fragment = el;
|
||
} else {
|
||
this.$el = el;
|
||
}
|
||
this.$el.__vue__ = this;
|
||
this._callHook('beforeCompile');
|
||
};
|
||
|
||
/**
|
||
* Create and bind a directive to an element.
|
||
*
|
||
* @param {String} name - directive name
|
||
* @param {Node} node - target node
|
||
* @param {Object} desc - parsed directive descriptor
|
||
* @param {Object} def - directive definition object
|
||
* @param {Vue} [host] - transclusion host component
|
||
* @param {Object} [scope] - v-for scope
|
||
* @param {Fragment} [frag] - owner fragment
|
||
*/
|
||
|
||
Vue.prototype._bindDir = function (descriptor, node, host, scope, frag) {
|
||
this._directives.push(new Directive(descriptor, this, node, host, scope, frag));
|
||
};
|
||
|
||
/**
|
||
* Teardown an instance, unobserves the data, unbind all the
|
||
* directives, turn off all the event listeners, etc.
|
||
*
|
||
* @param {Boolean} remove - whether to remove the DOM node.
|
||
* @param {Boolean} deferCleanup - if true, defer cleanup to
|
||
* be called later
|
||
*/
|
||
|
||
Vue.prototype._destroy = function (remove, deferCleanup) {
|
||
if (this._isBeingDestroyed) {
|
||
if (!deferCleanup) {
|
||
this._cleanup();
|
||
}
|
||
return;
|
||
}
|
||
|
||
var destroyReady;
|
||
var pendingRemoval;
|
||
|
||
var self = this;
|
||
// Cleanup should be called either synchronously or asynchronoysly as
|
||
// callback of this.$remove(), or if remove and deferCleanup are false.
|
||
// In any case it should be called after all other removing, unbinding and
|
||
// turning of is done
|
||
var cleanupIfPossible = function cleanupIfPossible() {
|
||
if (destroyReady && !pendingRemoval && !deferCleanup) {
|
||
self._cleanup();
|
||
}
|
||
};
|
||
|
||
// remove DOM element
|
||
if (remove && this.$el) {
|
||
pendingRemoval = true;
|
||
this.$remove(function () {
|
||
pendingRemoval = false;
|
||
cleanupIfPossible();
|
||
});
|
||
}
|
||
|
||
this._callHook('beforeDestroy');
|
||
this._isBeingDestroyed = true;
|
||
var i;
|
||
// remove self from parent. only necessary
|
||
// if parent is not being destroyed as well.
|
||
var parent = this.$parent;
|
||
if (parent && !parent._isBeingDestroyed) {
|
||
parent.$children.$remove(this);
|
||
// unregister ref (remove: true)
|
||
this._updateRef(true);
|
||
}
|
||
// destroy all children.
|
||
i = this.$children.length;
|
||
while (i--) {
|
||
this.$children[i].$destroy();
|
||
}
|
||
// teardown props
|
||
if (this._propsUnlinkFn) {
|
||
this._propsUnlinkFn();
|
||
}
|
||
// teardown all directives. this also tearsdown all
|
||
// directive-owned watchers.
|
||
if (this._unlinkFn) {
|
||
this._unlinkFn();
|
||
}
|
||
i = this._watchers.length;
|
||
while (i--) {
|
||
this._watchers[i].teardown();
|
||
}
|
||
// remove reference to self on $el
|
||
if (this.$el) {
|
||
this.$el.__vue__ = null;
|
||
}
|
||
|
||
destroyReady = true;
|
||
cleanupIfPossible();
|
||
};
|
||
|
||
/**
|
||
* Clean up to ensure garbage collection.
|
||
* This is called after the leave transition if there
|
||
* is any.
|
||
*/
|
||
|
||
Vue.prototype._cleanup = function () {
|
||
if (this._isDestroyed) {
|
||
return;
|
||
}
|
||
// remove self from owner fragment
|
||
// do it in cleanup so that we can call $destroy with
|
||
// defer right when a fragment is about to be removed.
|
||
if (this._frag) {
|
||
this._frag.children.$remove(this);
|
||
}
|
||
// remove reference from data ob
|
||
// frozen object may not have observer.
|
||
if (this._data.__ob__) {
|
||
this._data.__ob__.removeVm(this);
|
||
}
|
||
// Clean up references to private properties and other
|
||
// instances. preserve reference to _data so that proxy
|
||
// accessors still work. The only potential side effect
|
||
// here is that mutating the instance after it's destroyed
|
||
// may affect the state of other components that are still
|
||
// observing the same object, but that seems to be a
|
||
// reasonable responsibility for the user rather than
|
||
// always throwing an error on them.
|
||
this.$el = this.$parent = this.$root = this.$children = this._watchers = this._context = this._scope = this._directives = null;
|
||
// call the last hook...
|
||
this._isDestroyed = true;
|
||
this._callHook('destroyed');
|
||
// turn off all instance listeners.
|
||
this.$off();
|
||
};
|
||
}
|
||
|
||
function miscMixin (Vue) {
|
||
/**
|
||
* Apply a list of filter (descriptors) to a value.
|
||
* Using plain for loops here because this will be called in
|
||
* the getter of any watcher with filters so it is very
|
||
* performance sensitive.
|
||
*
|
||
* @param {*} value
|
||
* @param {*} [oldValue]
|
||
* @param {Array} filters
|
||
* @param {Boolean} write
|
||
* @return {*}
|
||
*/
|
||
|
||
Vue.prototype._applyFilters = function (value, oldValue, filters, write) {
|
||
var filter, fn, args, arg, offset, i, l, j, k;
|
||
for (i = 0, l = filters.length; i < l; i++) {
|
||
filter = filters[i];
|
||
fn = resolveAsset(this.$options, 'filters', filter.name);
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
assertAsset(fn, 'filter', filter.name);
|
||
}
|
||
if (!fn) continue;
|
||
fn = write ? fn.write : fn.read || fn;
|
||
if (typeof fn !== 'function') continue;
|
||
args = write ? [value, oldValue] : [value];
|
||
offset = write ? 2 : 1;
|
||
if (filter.args) {
|
||
for (j = 0, k = filter.args.length; j < k; j++) {
|
||
arg = filter.args[j];
|
||
args[j + offset] = arg.dynamic ? this.$get(arg.value) : arg.value;
|
||
}
|
||
}
|
||
value = fn.apply(this, args);
|
||
}
|
||
return value;
|
||
};
|
||
|
||
/**
|
||
* Resolve a component, depending on whether the component
|
||
* is defined normally or using an async factory function.
|
||
* Resolves synchronously if already resolved, otherwise
|
||
* resolves asynchronously and caches the resolved
|
||
* constructor on the factory.
|
||
*
|
||
* @param {String} id
|
||
* @param {Function} cb
|
||
*/
|
||
|
||
Vue.prototype._resolveComponent = function (id, cb) {
|
||
var factory = resolveAsset(this.$options, 'components', id);
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
assertAsset(factory, 'component', id);
|
||
}
|
||
if (!factory) {
|
||
return;
|
||
}
|
||
// async component factory
|
||
if (!factory.options) {
|
||
if (factory.resolved) {
|
||
// cached
|
||
cb(factory.resolved);
|
||
} else if (factory.requested) {
|
||
// pool callbacks
|
||
factory.pendingCallbacks.push(cb);
|
||
} else {
|
||
factory.requested = true;
|
||
var cbs = factory.pendingCallbacks = [cb];
|
||
factory.call(this, function resolve(res) {
|
||
if (isPlainObject(res)) {
|
||
res = Vue.extend(res);
|
||
}
|
||
// cache resolved
|
||
factory.resolved = res;
|
||
// invoke callbacks
|
||
for (var i = 0, l = cbs.length; i < l; i++) {
|
||
cbs[i](res);
|
||
}
|
||
}, function reject(reason) {
|
||
process.env.NODE_ENV !== 'production' && warn('Failed to resolve async component: ' + id + '. ' + (reason ? '\nReason: ' + reason : ''));
|
||
});
|
||
}
|
||
} else {
|
||
// normal component
|
||
cb(factory);
|
||
}
|
||
};
|
||
}
|
||
|
||
var filterRE$1 = /[^|]\|[^|]/;
|
||
|
||
function dataAPI (Vue) {
|
||
/**
|
||
* Get the value from an expression on this vm.
|
||
*
|
||
* @param {String} exp
|
||
* @param {Boolean} [asStatement]
|
||
* @return {*}
|
||
*/
|
||
|
||
Vue.prototype.$get = function (exp, asStatement) {
|
||
var res = parseExpression(exp);
|
||
if (res) {
|
||
if (asStatement && !isSimplePath(exp)) {
|
||
var self = this;
|
||
return function statementHandler() {
|
||
self.$arguments = toArray(arguments);
|
||
var result = res.get.call(self, self);
|
||
self.$arguments = null;
|
||
return result;
|
||
};
|
||
} else {
|
||
try {
|
||
return res.get.call(this, this);
|
||
} catch (e) {}
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Set the value from an expression on this vm.
|
||
* The expression must be a valid left-hand
|
||
* expression in an assignment.
|
||
*
|
||
* @param {String} exp
|
||
* @param {*} val
|
||
*/
|
||
|
||
Vue.prototype.$set = function (exp, val) {
|
||
var res = parseExpression(exp, true);
|
||
if (res && res.set) {
|
||
res.set.call(this, this, val);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Delete a property on the VM
|
||
*
|
||
* @param {String} key
|
||
*/
|
||
|
||
Vue.prototype.$delete = function (key) {
|
||
del(this._data, key);
|
||
};
|
||
|
||
/**
|
||
* Watch an expression, trigger callback when its
|
||
* value changes.
|
||
*
|
||
* @param {String|Function} expOrFn
|
||
* @param {Function} cb
|
||
* @param {Object} [options]
|
||
* - {Boolean} deep
|
||
* - {Boolean} immediate
|
||
* @return {Function} - unwatchFn
|
||
*/
|
||
|
||
Vue.prototype.$watch = function (expOrFn, cb, options) {
|
||
var vm = this;
|
||
var parsed;
|
||
if (typeof expOrFn === 'string') {
|
||
parsed = parseDirective(expOrFn);
|
||
expOrFn = parsed.expression;
|
||
}
|
||
var watcher = new Watcher(vm, expOrFn, cb, {
|
||
deep: options && options.deep,
|
||
sync: options && options.sync,
|
||
filters: parsed && parsed.filters,
|
||
user: !options || options.user !== false
|
||
});
|
||
if (options && options.immediate) {
|
||
cb.call(vm, watcher.value);
|
||
}
|
||
return function unwatchFn() {
|
||
watcher.teardown();
|
||
};
|
||
};
|
||
|
||
/**
|
||
* Evaluate a text directive, including filters.
|
||
*
|
||
* @param {String} text
|
||
* @param {Boolean} [asStatement]
|
||
* @return {String}
|
||
*/
|
||
|
||
Vue.prototype.$eval = function (text, asStatement) {
|
||
// check for filters.
|
||
if (filterRE$1.test(text)) {
|
||
var dir = parseDirective(text);
|
||
// the filter regex check might give false positive
|
||
// for pipes inside strings, so it's possible that
|
||
// we don't get any filters here
|
||
var val = this.$get(dir.expression, asStatement);
|
||
return dir.filters ? this._applyFilters(val, null, dir.filters) : val;
|
||
} else {
|
||
// no filter
|
||
return this.$get(text, asStatement);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Interpolate a piece of template text.
|
||
*
|
||
* @param {String} text
|
||
* @return {String}
|
||
*/
|
||
|
||
Vue.prototype.$interpolate = function (text) {
|
||
var tokens = parseText(text);
|
||
var vm = this;
|
||
if (tokens) {
|
||
if (tokens.length === 1) {
|
||
return vm.$eval(tokens[0].value) + '';
|
||
} else {
|
||
return tokens.map(function (token) {
|
||
return token.tag ? vm.$eval(token.value) : token.value;
|
||
}).join('');
|
||
}
|
||
} else {
|
||
return text;
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Log instance data as a plain JS object
|
||
* so that it is easier to inspect in console.
|
||
* This method assumes console is available.
|
||
*
|
||
* @param {String} [path]
|
||
*/
|
||
|
||
Vue.prototype.$log = function (path) {
|
||
var data = path ? getPath(this._data, path) : this._data;
|
||
if (data) {
|
||
data = clean(data);
|
||
}
|
||
// include computed fields
|
||
if (!path) {
|
||
for (var key in this.$options.computed) {
|
||
data[key] = clean(this[key]);
|
||
}
|
||
}
|
||
console.log(data);
|
||
};
|
||
|
||
/**
|
||
* "clean" a getter/setter converted object into a plain
|
||
* object copy.
|
||
*
|
||
* @param {Object} - obj
|
||
* @return {Object}
|
||
*/
|
||
|
||
function clean(obj) {
|
||
return JSON.parse(JSON.stringify(obj));
|
||
}
|
||
}
|
||
|
||
function domAPI (Vue) {
|
||
/**
|
||
* Convenience on-instance nextTick. The callback is
|
||
* auto-bound to the instance, and this avoids component
|
||
* modules having to rely on the global Vue.
|
||
*
|
||
* @param {Function} fn
|
||
*/
|
||
|
||
Vue.prototype.$nextTick = function (fn) {
|
||
nextTick(fn, this);
|
||
};
|
||
|
||
/**
|
||
* Append instance to target
|
||
*
|
||
* @param {Node} target
|
||
* @param {Function} [cb]
|
||
* @param {Boolean} [withTransition] - defaults to true
|
||
*/
|
||
|
||
Vue.prototype.$appendTo = function (target, cb, withTransition) {
|
||
return insert(this, target, cb, withTransition, append, appendWithTransition);
|
||
};
|
||
|
||
/**
|
||
* Prepend instance to target
|
||
*
|
||
* @param {Node} target
|
||
* @param {Function} [cb]
|
||
* @param {Boolean} [withTransition] - defaults to true
|
||
*/
|
||
|
||
Vue.prototype.$prependTo = function (target, cb, withTransition) {
|
||
target = query(target);
|
||
if (target.hasChildNodes()) {
|
||
this.$before(target.firstChild, cb, withTransition);
|
||
} else {
|
||
this.$appendTo(target, cb, withTransition);
|
||
}
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Insert instance before target
|
||
*
|
||
* @param {Node} target
|
||
* @param {Function} [cb]
|
||
* @param {Boolean} [withTransition] - defaults to true
|
||
*/
|
||
|
||
Vue.prototype.$before = function (target, cb, withTransition) {
|
||
return insert(this, target, cb, withTransition, beforeWithCb, beforeWithTransition);
|
||
};
|
||
|
||
/**
|
||
* Insert instance after target
|
||
*
|
||
* @param {Node} target
|
||
* @param {Function} [cb]
|
||
* @param {Boolean} [withTransition] - defaults to true
|
||
*/
|
||
|
||
Vue.prototype.$after = function (target, cb, withTransition) {
|
||
target = query(target);
|
||
if (target.nextSibling) {
|
||
this.$before(target.nextSibling, cb, withTransition);
|
||
} else {
|
||
this.$appendTo(target.parentNode, cb, withTransition);
|
||
}
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Remove instance from DOM
|
||
*
|
||
* @param {Function} [cb]
|
||
* @param {Boolean} [withTransition] - defaults to true
|
||
*/
|
||
|
||
Vue.prototype.$remove = function (cb, withTransition) {
|
||
if (!this.$el.parentNode) {
|
||
return cb && cb();
|
||
}
|
||
var inDocument = this._isAttached && inDoc(this.$el);
|
||
// if we are not in document, no need to check
|
||
// for transitions
|
||
if (!inDocument) withTransition = false;
|
||
var self = this;
|
||
var realCb = function realCb() {
|
||
if (inDocument) self._callHook('detached');
|
||
if (cb) cb();
|
||
};
|
||
if (this._isFragment) {
|
||
removeNodeRange(this._fragmentStart, this._fragmentEnd, this, this._fragment, realCb);
|
||
} else {
|
||
var op = withTransition === false ? removeWithCb : removeWithTransition;
|
||
op(this.$el, this, realCb);
|
||
}
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Shared DOM insertion function.
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {Element} target
|
||
* @param {Function} [cb]
|
||
* @param {Boolean} [withTransition]
|
||
* @param {Function} op1 - op for non-transition insert
|
||
* @param {Function} op2 - op for transition insert
|
||
* @return vm
|
||
*/
|
||
|
||
function insert(vm, target, cb, withTransition, op1, op2) {
|
||
target = query(target);
|
||
var targetIsDetached = !inDoc(target);
|
||
var op = withTransition === false || targetIsDetached ? op1 : op2;
|
||
var shouldCallHook = !targetIsDetached && !vm._isAttached && !inDoc(vm.$el);
|
||
if (vm._isFragment) {
|
||
mapNodeRange(vm._fragmentStart, vm._fragmentEnd, function (node) {
|
||
op(node, target, vm);
|
||
});
|
||
cb && cb();
|
||
} else {
|
||
op(vm.$el, target, vm, cb);
|
||
}
|
||
if (shouldCallHook) {
|
||
vm._callHook('attached');
|
||
}
|
||
return vm;
|
||
}
|
||
|
||
/**
|
||
* Check for selectors
|
||
*
|
||
* @param {String|Element} el
|
||
*/
|
||
|
||
function query(el) {
|
||
return typeof el === 'string' ? document.querySelector(el) : el;
|
||
}
|
||
|
||
/**
|
||
* Append operation that takes a callback.
|
||
*
|
||
* @param {Node} el
|
||
* @param {Node} target
|
||
* @param {Vue} vm - unused
|
||
* @param {Function} [cb]
|
||
*/
|
||
|
||
function append(el, target, vm, cb) {
|
||
target.appendChild(el);
|
||
if (cb) cb();
|
||
}
|
||
|
||
/**
|
||
* InsertBefore operation that takes a callback.
|
||
*
|
||
* @param {Node} el
|
||
* @param {Node} target
|
||
* @param {Vue} vm - unused
|
||
* @param {Function} [cb]
|
||
*/
|
||
|
||
function beforeWithCb(el, target, vm, cb) {
|
||
before(el, target);
|
||
if (cb) cb();
|
||
}
|
||
|
||
/**
|
||
* Remove operation that takes a callback.
|
||
*
|
||
* @param {Node} el
|
||
* @param {Vue} vm - unused
|
||
* @param {Function} [cb]
|
||
*/
|
||
|
||
function removeWithCb(el, vm, cb) {
|
||
remove(el);
|
||
if (cb) cb();
|
||
}
|
||
}
|
||
|
||
function eventsAPI (Vue) {
|
||
/**
|
||
* Listen on the given `event` with `fn`.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
*/
|
||
|
||
Vue.prototype.$on = function (event, fn) {
|
||
(this._events[event] || (this._events[event] = [])).push(fn);
|
||
modifyListenerCount(this, event, 1);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Adds an `event` listener that will be invoked a single
|
||
* time then automatically removed.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
*/
|
||
|
||
Vue.prototype.$once = function (event, fn) {
|
||
var self = this;
|
||
function on() {
|
||
self.$off(event, on);
|
||
fn.apply(this, arguments);
|
||
}
|
||
on.fn = fn;
|
||
this.$on(event, on);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Remove the given callback for `event` or all
|
||
* registered callbacks.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
*/
|
||
|
||
Vue.prototype.$off = function (event, fn) {
|
||
var cbs;
|
||
// all
|
||
if (!arguments.length) {
|
||
if (this.$parent) {
|
||
for (event in this._events) {
|
||
cbs = this._events[event];
|
||
if (cbs) {
|
||
modifyListenerCount(this, event, -cbs.length);
|
||
}
|
||
}
|
||
}
|
||
this._events = {};
|
||
return this;
|
||
}
|
||
// specific event
|
||
cbs = this._events[event];
|
||
if (!cbs) {
|
||
return this;
|
||
}
|
||
if (arguments.length === 1) {
|
||
modifyListenerCount(this, event, -cbs.length);
|
||
this._events[event] = null;
|
||
return this;
|
||
}
|
||
// specific handler
|
||
var cb;
|
||
var i = cbs.length;
|
||
while (i--) {
|
||
cb = cbs[i];
|
||
if (cb === fn || cb.fn === fn) {
|
||
modifyListenerCount(this, event, -1);
|
||
cbs.splice(i, 1);
|
||
break;
|
||
}
|
||
}
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Trigger an event on self.
|
||
*
|
||
* @param {String|Object} event
|
||
* @return {Boolean} shouldPropagate
|
||
*/
|
||
|
||
Vue.prototype.$emit = function (event) {
|
||
var isSource = typeof event === 'string';
|
||
event = isSource ? event : event.name;
|
||
var cbs = this._events[event];
|
||
var shouldPropagate = isSource || !cbs;
|
||
if (cbs) {
|
||
cbs = cbs.length > 1 ? toArray(cbs) : cbs;
|
||
// this is a somewhat hacky solution to the question raised
|
||
// in #2102: for an inline component listener like <comp @test="doThis">,
|
||
// the propagation handling is somewhat broken. Therefore we
|
||
// need to treat these inline callbacks differently.
|
||
var hasParentCbs = isSource && cbs.some(function (cb) {
|
||
return cb._fromParent;
|
||
});
|
||
if (hasParentCbs) {
|
||
shouldPropagate = false;
|
||
}
|
||
var args = toArray(arguments, 1);
|
||
for (var i = 0, l = cbs.length; i < l; i++) {
|
||
var cb = cbs[i];
|
||
var res = cb.apply(this, args);
|
||
if (res === true && (!hasParentCbs || cb._fromParent)) {
|
||
shouldPropagate = true;
|
||
}
|
||
}
|
||
}
|
||
return shouldPropagate;
|
||
};
|
||
|
||
/**
|
||
* Recursively broadcast an event to all children instances.
|
||
*
|
||
* @param {String|Object} event
|
||
* @param {...*} additional arguments
|
||
*/
|
||
|
||
Vue.prototype.$broadcast = function (event) {
|
||
var isSource = typeof event === 'string';
|
||
event = isSource ? event : event.name;
|
||
// if no child has registered for this event,
|
||
// then there's no need to broadcast.
|
||
if (!this._eventsCount[event]) return;
|
||
var children = this.$children;
|
||
var args = toArray(arguments);
|
||
if (isSource) {
|
||
// use object event to indicate non-source emit
|
||
// on children
|
||
args[0] = { name: event, source: this };
|
||
}
|
||
for (var i = 0, l = children.length; i < l; i++) {
|
||
var child = children[i];
|
||
var shouldPropagate = child.$emit.apply(child, args);
|
||
if (shouldPropagate) {
|
||
child.$broadcast.apply(child, args);
|
||
}
|
||
}
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Recursively propagate an event up the parent chain.
|
||
*
|
||
* @param {String} event
|
||
* @param {...*} additional arguments
|
||
*/
|
||
|
||
Vue.prototype.$dispatch = function (event) {
|
||
var shouldPropagate = this.$emit.apply(this, arguments);
|
||
if (!shouldPropagate) return;
|
||
var parent = this.$parent;
|
||
var args = toArray(arguments);
|
||
// use object event to indicate non-source emit
|
||
// on parents
|
||
args[0] = { name: event, source: this };
|
||
while (parent) {
|
||
shouldPropagate = parent.$emit.apply(parent, args);
|
||
parent = shouldPropagate ? parent.$parent : null;
|
||
}
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Modify the listener counts on all parents.
|
||
* This bookkeeping allows $broadcast to return early when
|
||
* no child has listened to a certain event.
|
||
*
|
||
* @param {Vue} vm
|
||
* @param {String} event
|
||
* @param {Number} count
|
||
*/
|
||
|
||
var hookRE = /^hook:/;
|
||
function modifyListenerCount(vm, event, count) {
|
||
var parent = vm.$parent;
|
||
// hooks do not get broadcasted so no need
|
||
// to do bookkeeping for them
|
||
if (!parent || !count || hookRE.test(event)) return;
|
||
while (parent) {
|
||
parent._eventsCount[event] = (parent._eventsCount[event] || 0) + count;
|
||
parent = parent.$parent;
|
||
}
|
||
}
|
||
}
|
||
|
||
function lifecycleAPI (Vue) {
|
||
/**
|
||
* Set instance target element and kick off the compilation
|
||
* process. The passed in `el` can be a selector string, an
|
||
* existing Element, or a DocumentFragment (for block
|
||
* instances).
|
||
*
|
||
* @param {Element|DocumentFragment|string} el
|
||
* @public
|
||
*/
|
||
|
||
Vue.prototype.$mount = function (el) {
|
||
if (this._isCompiled) {
|
||
process.env.NODE_ENV !== 'production' && warn('$mount() should be called only once.');
|
||
return;
|
||
}
|
||
el = query(el);
|
||
if (!el) {
|
||
el = document.createElement('div');
|
||
}
|
||
this._compile(el);
|
||
this._initDOMHooks();
|
||
if (inDoc(this.$el)) {
|
||
this._callHook('attached');
|
||
ready.call(this);
|
||
} else {
|
||
this.$once('hook:attached', ready);
|
||
}
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Mark an instance as ready.
|
||
*/
|
||
|
||
function ready() {
|
||
this._isAttached = true;
|
||
this._isReady = true;
|
||
this._callHook('ready');
|
||
}
|
||
|
||
/**
|
||
* Teardown the instance, simply delegate to the internal
|
||
* _destroy.
|
||
*/
|
||
|
||
Vue.prototype.$destroy = function (remove, deferCleanup) {
|
||
this._destroy(remove, deferCleanup);
|
||
};
|
||
|
||
/**
|
||
* Partially compile a piece of DOM and return a
|
||
* decompile function.
|
||
*
|
||
* @param {Element|DocumentFragment} el
|
||
* @param {Vue} [host]
|
||
* @return {Function}
|
||
*/
|
||
|
||
Vue.prototype.$compile = function (el, host, scope, frag) {
|
||
return compile(el, this.$options, true)(this, el, host, scope, frag);
|
||
};
|
||
}
|
||
|
||
/**
|
||
* The exposed Vue constructor.
|
||
*
|
||
* API conventions:
|
||
* - public API methods/properties are prefixed with `$`
|
||
* - internal methods/properties are prefixed with `_`
|
||
* - non-prefixed properties are assumed to be proxied user
|
||
* data.
|
||
*
|
||
* @constructor
|
||
* @param {Object} [options]
|
||
* @public
|
||
*/
|
||
|
||
function Vue(options) {
|
||
this._init(options);
|
||
}
|
||
|
||
// install internals
|
||
initMixin(Vue);
|
||
stateMixin(Vue);
|
||
eventsMixin(Vue);
|
||
lifecycleMixin(Vue);
|
||
miscMixin(Vue);
|
||
|
||
// install instance APIs
|
||
dataAPI(Vue);
|
||
domAPI(Vue);
|
||
eventsAPI(Vue);
|
||
lifecycleAPI(Vue);
|
||
|
||
var slot = {
|
||
|
||
priority: SLOT,
|
||
params: ['name'],
|
||
|
||
bind: function bind() {
|
||
// this was resolved during component transclusion
|
||
var name = this.params.name || 'default';
|
||
var content = this.vm._slotContents && this.vm._slotContents[name];
|
||
if (!content || !content.hasChildNodes()) {
|
||
this.fallback();
|
||
} else {
|
||
this.compile(content.cloneNode(true), this.vm._context, this.vm);
|
||
}
|
||
},
|
||
|
||
compile: function compile(content, context, host) {
|
||
if (content && context) {
|
||
if (this.el.hasChildNodes() && content.childNodes.length === 1 && content.childNodes[0].nodeType === 1 && content.childNodes[0].hasAttribute('v-if')) {
|
||
// if the inserted slot has v-if
|
||
// inject fallback content as the v-else
|
||
var elseBlock = document.createElement('template');
|
||
elseBlock.setAttribute('v-else', '');
|
||
elseBlock.innerHTML = this.el.innerHTML;
|
||
// the else block should be compiled in child scope
|
||
elseBlock._context = this.vm;
|
||
content.appendChild(elseBlock);
|
||
}
|
||
var scope = host ? host._scope : this._scope;
|
||
this.unlink = context.$compile(content, host, scope, this._frag);
|
||
}
|
||
if (content) {
|
||
replace(this.el, content);
|
||
} else {
|
||
remove(this.el);
|
||
}
|
||
},
|
||
|
||
fallback: function fallback() {
|
||
this.compile(extractContent(this.el, true), this.vm);
|
||
},
|
||
|
||
unbind: function unbind() {
|
||
if (this.unlink) {
|
||
this.unlink();
|
||
}
|
||
}
|
||
};
|
||
|
||
var partial = {
|
||
|
||
priority: PARTIAL,
|
||
|
||
params: ['name'],
|
||
|
||
// watch changes to name for dynamic partials
|
||
paramWatchers: {
|
||
name: function name(value) {
|
||
vIf.remove.call(this);
|
||
if (value) {
|
||
this.insert(value);
|
||
}
|
||
}
|
||
},
|
||
|
||
bind: function bind() {
|
||
this.anchor = createAnchor('v-partial');
|
||
replace(this.el, this.anchor);
|
||
this.insert(this.params.name);
|
||
},
|
||
|
||
insert: function insert(id) {
|
||
var partial = resolveAsset(this.vm.$options, 'partials', id);
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
assertAsset(partial, 'partial', id);
|
||
}
|
||
if (partial) {
|
||
this.factory = new FragmentFactory(this.vm, partial);
|
||
vIf.insert.call(this);
|
||
}
|
||
},
|
||
|
||
unbind: function unbind() {
|
||
if (this.frag) {
|
||
this.frag.destroy();
|
||
}
|
||
}
|
||
};
|
||
|
||
var elementDirectives = {
|
||
slot: slot,
|
||
partial: partial
|
||
};
|
||
|
||
var convertArray = vFor._postProcess;
|
||
|
||
/**
|
||
* Limit filter for arrays
|
||
*
|
||
* @param {Number} n
|
||
* @param {Number} offset (Decimal expected)
|
||
*/
|
||
|
||
function limitBy(arr, n, offset) {
|
||
offset = offset ? parseInt(offset, 10) : 0;
|
||
n = toNumber(n);
|
||
return typeof n === 'number' ? arr.slice(offset, offset + n) : arr;
|
||
}
|
||
|
||
/**
|
||
* Filter filter for arrays
|
||
*
|
||
* @param {String} search
|
||
* @param {String} [delimiter]
|
||
* @param {String} ...dataKeys
|
||
*/
|
||
|
||
function filterBy(arr, search, delimiter) {
|
||
arr = convertArray(arr);
|
||
if (search == null) {
|
||
return arr;
|
||
}
|
||
if (typeof search === 'function') {
|
||
return arr.filter(search);
|
||
}
|
||
// cast to lowercase string
|
||
search = ('' + search).toLowerCase();
|
||
// allow optional `in` delimiter
|
||
// because why not
|
||
var n = delimiter === 'in' ? 3 : 2;
|
||
// extract and flatten keys
|
||
var keys = toArray(arguments, n).reduce(function (prev, cur) {
|
||
return prev.concat(cur);
|
||
}, []);
|
||
var res = [];
|
||
var item, key, val, j;
|
||
for (var i = 0, l = arr.length; i < l; i++) {
|
||
item = arr[i];
|
||
val = item && item.$value || item;
|
||
j = keys.length;
|
||
if (j) {
|
||
while (j--) {
|
||
key = keys[j];
|
||
if (key === '$key' && contains$1(item.$key, search) || contains$1(getPath(val, key), search)) {
|
||
res.push(item);
|
||
break;
|
||
}
|
||
}
|
||
} else if (contains$1(item, search)) {
|
||
res.push(item);
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
|
||
/**
|
||
* Filter filter for arrays
|
||
*
|
||
* @param {String} sortKey
|
||
* @param {String} reverse
|
||
*/
|
||
|
||
function orderBy(arr, sortKey, reverse) {
|
||
arr = convertArray(arr);
|
||
if (!sortKey) {
|
||
return arr;
|
||
}
|
||
var order = reverse && reverse < 0 ? -1 : 1;
|
||
// sort on a copy to avoid mutating original array
|
||
return arr.slice().sort(function (a, b) {
|
||
if (sortKey !== '$key') {
|
||
if (isObject(a) && '$value' in a) a = a.$value;
|
||
if (isObject(b) && '$value' in b) b = b.$value;
|
||
}
|
||
a = isObject(a) ? getPath(a, sortKey) : a;
|
||
b = isObject(b) ? getPath(b, sortKey) : b;
|
||
return a === b ? 0 : a > b ? order : -order;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* String contain helper
|
||
*
|
||
* @param {*} val
|
||
* @param {String} search
|
||
*/
|
||
|
||
function contains$1(val, search) {
|
||
var i;
|
||
if (isPlainObject(val)) {
|
||
var keys = Object.keys(val);
|
||
i = keys.length;
|
||
while (i--) {
|
||
if (contains$1(val[keys[i]], search)) {
|
||
return true;
|
||
}
|
||
}
|
||
} else if (isArray(val)) {
|
||
i = val.length;
|
||
while (i--) {
|
||
if (contains$1(val[i], search)) {
|
||
return true;
|
||
}
|
||
}
|
||
} else if (val != null) {
|
||
return val.toString().toLowerCase().indexOf(search) > -1;
|
||
}
|
||
}
|
||
|
||
var digitsRE = /(\d{3})(?=\d)/g;
|
||
|
||
// asset collections must be a plain object.
|
||
var filters = {
|
||
|
||
orderBy: orderBy,
|
||
filterBy: filterBy,
|
||
limitBy: limitBy,
|
||
|
||
/**
|
||
* Stringify value.
|
||
*
|
||
* @param {Number} indent
|
||
*/
|
||
|
||
json: {
|
||
read: function read(value, indent) {
|
||
return typeof value === 'string' ? value : JSON.stringify(value, null, Number(indent) || 2);
|
||
},
|
||
write: function write(value) {
|
||
try {
|
||
return JSON.parse(value);
|
||
} catch (e) {
|
||
return value;
|
||
}
|
||
}
|
||
},
|
||
|
||
/**
|
||
* 'abc' => 'Abc'
|
||
*/
|
||
|
||
capitalize: function capitalize(value) {
|
||
if (!value && value !== 0) return '';
|
||
value = value.toString();
|
||
return value.charAt(0).toUpperCase() + value.slice(1);
|
||
},
|
||
|
||
/**
|
||
* 'abc' => 'ABC'
|
||
*/
|
||
|
||
uppercase: function uppercase(value) {
|
||
return value || value === 0 ? value.toString().toUpperCase() : '';
|
||
},
|
||
|
||
/**
|
||
* 'AbC' => 'abc'
|
||
*/
|
||
|
||
lowercase: function lowercase(value) {
|
||
return value || value === 0 ? value.toString().toLowerCase() : '';
|
||
},
|
||
|
||
/**
|
||
* 12345 => $12,345.00
|
||
*
|
||
* @param {String} sign
|
||
*/
|
||
|
||
currency: function currency(value, _currency) {
|
||
value = parseFloat(value);
|
||
if (!isFinite(value) || !value && value !== 0) return '';
|
||
_currency = _currency != null ? _currency : '$';
|
||
var stringified = Math.abs(value).toFixed(2);
|
||
var _int = stringified.slice(0, -3);
|
||
var i = _int.length % 3;
|
||
var head = i > 0 ? _int.slice(0, i) + (_int.length > 3 ? ',' : '') : '';
|
||
var _float = stringified.slice(-3);
|
||
var sign = value < 0 ? '-' : '';
|
||
return sign + _currency + head + _int.slice(i).replace(digitsRE, '$1,') + _float;
|
||
},
|
||
|
||
/**
|
||
* 'item' => 'items'
|
||
*
|
||
* @params
|
||
* an array of strings corresponding to
|
||
* the single, double, triple ... forms of the word to
|
||
* be pluralized. When the number to be pluralized
|
||
* exceeds the length of the args, it will use the last
|
||
* entry in the array.
|
||
*
|
||
* e.g. ['single', 'double', 'triple', 'multiple']
|
||
*/
|
||
|
||
pluralize: function pluralize(value) {
|
||
var args = toArray(arguments, 1);
|
||
return args.length > 1 ? args[value % 10 - 1] || args[args.length - 1] : args[0] + (value === 1 ? '' : 's');
|
||
},
|
||
|
||
/**
|
||
* Debounce a handler function.
|
||
*
|
||
* @param {Function} handler
|
||
* @param {Number} delay = 300
|
||
* @return {Function}
|
||
*/
|
||
|
||
debounce: function debounce(handler, delay) {
|
||
if (!handler) return;
|
||
if (!delay) {
|
||
delay = 300;
|
||
}
|
||
return _debounce(handler, delay);
|
||
}
|
||
};
|
||
|
||
function installGlobalAPI (Vue) {
|
||
/**
|
||
* Vue and every constructor that extends Vue has an
|
||
* associated options object, which can be accessed during
|
||
* compilation steps as `this.constructor.options`.
|
||
*
|
||
* These can be seen as the default options of every
|
||
* Vue instance.
|
||
*/
|
||
|
||
Vue.options = {
|
||
directives: directives,
|
||
elementDirectives: elementDirectives,
|
||
filters: filters,
|
||
transitions: {},
|
||
components: {},
|
||
partials: {},
|
||
replace: true
|
||
};
|
||
|
||
/**
|
||
* Expose useful internals
|
||
*/
|
||
|
||
Vue.util = util;
|
||
Vue.config = config;
|
||
Vue.set = set;
|
||
Vue['delete'] = del;
|
||
Vue.nextTick = nextTick;
|
||
|
||
/**
|
||
* The following are exposed for advanced usage / plugins
|
||
*/
|
||
|
||
Vue.compiler = compiler;
|
||
Vue.FragmentFactory = FragmentFactory;
|
||
Vue.internalDirectives = internalDirectives;
|
||
Vue.parsers = {
|
||
path: path,
|
||
text: text,
|
||
template: template,
|
||
directive: directive,
|
||
expression: expression
|
||
};
|
||
|
||
/**
|
||
* Each instance constructor, including Vue, has a unique
|
||
* cid. This enables us to create wrapped "child
|
||
* constructors" for prototypal inheritance and cache them.
|
||
*/
|
||
|
||
Vue.cid = 0;
|
||
var cid = 1;
|
||
|
||
/**
|
||
* Class inheritance
|
||
*
|
||
* @param {Object} extendOptions
|
||
*/
|
||
|
||
Vue.extend = function (extendOptions) {
|
||
extendOptions = extendOptions || {};
|
||
var Super = this;
|
||
var isFirstExtend = Super.cid === 0;
|
||
if (isFirstExtend && extendOptions._Ctor) {
|
||
return extendOptions._Ctor;
|
||
}
|
||
var name = extendOptions.name || Super.options.name;
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
if (!/^[a-zA-Z][\w-]*$/.test(name)) {
|
||
warn('Invalid component name: "' + name + '". Component names ' + 'can only contain alphanumeric characaters and the hyphen.');
|
||
name = null;
|
||
}
|
||
}
|
||
var Sub = createClass(name || 'VueComponent');
|
||
Sub.prototype = Object.create(Super.prototype);
|
||
Sub.prototype.constructor = Sub;
|
||
Sub.cid = cid++;
|
||
Sub.options = mergeOptions(Super.options, extendOptions);
|
||
Sub['super'] = Super;
|
||
// allow further extension
|
||
Sub.extend = Super.extend;
|
||
// create asset registers, so extended classes
|
||
// can have their private assets too.
|
||
config._assetTypes.forEach(function (type) {
|
||
Sub[type] = Super[type];
|
||
});
|
||
// enable recursive self-lookup
|
||
if (name) {
|
||
Sub.options.components[name] = Sub;
|
||
}
|
||
// cache constructor
|
||
if (isFirstExtend) {
|
||
extendOptions._Ctor = Sub;
|
||
}
|
||
return Sub;
|
||
};
|
||
|
||
/**
|
||
* A function that returns a sub-class constructor with the
|
||
* given name. This gives us much nicer output when
|
||
* logging instances in the console.
|
||
*
|
||
* @param {String} name
|
||
* @return {Function}
|
||
*/
|
||
|
||
function createClass(name) {
|
||
/* eslint-disable no-new-func */
|
||
return new Function('return function ' + classify(name) + ' (options) { this._init(options) }')();
|
||
/* eslint-enable no-new-func */
|
||
}
|
||
|
||
/**
|
||
* Plugin system
|
||
*
|
||
* @param {Object} plugin
|
||
*/
|
||
|
||
Vue.use = function (plugin) {
|
||
/* istanbul ignore if */
|
||
if (plugin.installed) {
|
||
return;
|
||
}
|
||
// additional parameters
|
||
var args = toArray(arguments, 1);
|
||
args.unshift(this);
|
||
if (typeof plugin.install === 'function') {
|
||
plugin.install.apply(plugin, args);
|
||
} else {
|
||
plugin.apply(null, args);
|
||
}
|
||
plugin.installed = true;
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Apply a global mixin by merging it into the default
|
||
* options.
|
||
*/
|
||
|
||
Vue.mixin = function (mixin) {
|
||
Vue.options = mergeOptions(Vue.options, mixin);
|
||
};
|
||
|
||
/**
|
||
* Create asset registration methods with the following
|
||
* signature:
|
||
*
|
||
* @param {String} id
|
||
* @param {*} definition
|
||
*/
|
||
|
||
config._assetTypes.forEach(function (type) {
|
||
Vue[type] = function (id, definition) {
|
||
if (!definition) {
|
||
return this.options[type + 's'][id];
|
||
} else {
|
||
/* istanbul ignore if */
|
||
if (process.env.NODE_ENV !== 'production') {
|
||
if (type === 'component' && (commonTagRE.test(id) || reservedTagRE.test(id))) {
|
||
warn('Do not use built-in or reserved HTML elements as component ' + 'id: ' + id);
|
||
}
|
||
}
|
||
if (type === 'component' && isPlainObject(definition)) {
|
||
definition.name = id;
|
||
definition = Vue.extend(definition);
|
||
}
|
||
this.options[type + 's'][id] = definition;
|
||
return definition;
|
||
}
|
||
};
|
||
});
|
||
|
||
// expose internal transition API
|
||
extend(Vue.transition, transition);
|
||
}
|
||
|
||
installGlobalAPI(Vue);
|
||
|
||
Vue.version = '1.0.17';
|
||
|
||
// devtools global hook
|
||
/* istanbul ignore next */
|
||
if (devtools) {
|
||
devtools.emit('init', Vue);
|
||
} else if (process.env.NODE_ENV !== 'production' && inBrowser && /Chrome\/\d+/.test(window.navigator.userAgent)) {
|
||
console.log('Download the Vue Devtools for a better development experience:\n' + 'https://github.com/vuejs/vue-devtools');
|
||
}
|
||
|
||
module.exports = Vue;
|
||
}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"_process":137}],152:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/vueify-insert-css/index.js", module);
|
||
(function(){
|
||
var inserted = exports.cache = {}
|
||
|
||
exports.insert = function (css) {
|
||
if (inserted[css]) return
|
||
inserted[css] = true
|
||
|
||
var elem = document.createElement('style')
|
||
elem.setAttribute('type', 'text/css')
|
||
|
||
if ('textContent' in elem) {
|
||
elem.textContent = css
|
||
} else {
|
||
elem.styleSheet.cssText = css
|
||
}
|
||
|
||
document.getElementsByTagName('head')[0].appendChild(elem)
|
||
return elem
|
||
}
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],153:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/vuex/dist/vuex.js", module);
|
||
(function(){
|
||
/*!
|
||
* Vuex v0.6.2
|
||
* (c) 2016 Evan You
|
||
* Released under the MIT License.
|
||
*/
|
||
(function (global, factory) {
|
||
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
|
||
typeof define === 'function' && define.amd ? define(factory) :
|
||
(global.Vuex = factory());
|
||
}(this, function () { 'use strict';
|
||
|
||
var babelHelpers = {};
|
||
babelHelpers.typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
|
||
return typeof obj;
|
||
} : function (obj) {
|
||
return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj;
|
||
};
|
||
|
||
babelHelpers.classCallCheck = function (instance, Constructor) {
|
||
if (!(instance instanceof Constructor)) {
|
||
throw new TypeError("Cannot call a class as a function");
|
||
}
|
||
};
|
||
|
||
babelHelpers.createClass = function () {
|
||
function defineProperties(target, props) {
|
||
for (var i = 0; i < props.length; i++) {
|
||
var descriptor = props[i];
|
||
descriptor.enumerable = descriptor.enumerable || false;
|
||
descriptor.configurable = true;
|
||
if ("value" in descriptor) descriptor.writable = true;
|
||
Object.defineProperty(target, descriptor.key, descriptor);
|
||
}
|
||
}
|
||
|
||
return function (Constructor, protoProps, staticProps) {
|
||
if (protoProps) defineProperties(Constructor.prototype, protoProps);
|
||
if (staticProps) defineProperties(Constructor, staticProps);
|
||
return Constructor;
|
||
};
|
||
}();
|
||
|
||
babelHelpers.toConsumableArray = function (arr) {
|
||
if (Array.isArray(arr)) {
|
||
for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
|
||
|
||
return arr2;
|
||
} else {
|
||
return Array.from(arr);
|
||
}
|
||
};
|
||
|
||
babelHelpers;
|
||
|
||
/**
|
||
* Merge an array of objects into one.
|
||
*
|
||
* @param {Array<Object>} arr
|
||
* @return {Object}
|
||
*/
|
||
|
||
function mergeObjects(arr) {
|
||
return arr.reduce(function (prev, obj) {
|
||
Object.keys(obj).forEach(function (key) {
|
||
var existing = prev[key];
|
||
if (existing) {
|
||
// allow multiple mutation objects to contain duplicate
|
||
// handlers for the same mutation type
|
||
if (Array.isArray(existing)) {
|
||
existing.push(obj[key]);
|
||
} else {
|
||
prev[key] = [prev[key], obj[key]];
|
||
}
|
||
} else {
|
||
prev[key] = obj[key];
|
||
}
|
||
});
|
||
return prev;
|
||
}, {});
|
||
}
|
||
|
||
/**
|
||
* Deep clone an object. Faster than JSON.parse(JSON.stringify()).
|
||
*
|
||
* @param {*} obj
|
||
* @return {*}
|
||
*/
|
||
|
||
function deepClone(obj) {
|
||
if (Array.isArray(obj)) {
|
||
return obj.map(deepClone);
|
||
} else if (obj && (typeof obj === 'undefined' ? 'undefined' : babelHelpers.typeof(obj)) === 'object') {
|
||
var cloned = {};
|
||
var keys = Object.keys(obj);
|
||
for (var i = 0, l = keys.length; i < l; i++) {
|
||
var key = keys[i];
|
||
cloned[key] = deepClone(obj[key]);
|
||
}
|
||
return cloned;
|
||
} else {
|
||
return obj;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Hacks to get access to Vue internals.
|
||
* Maybe we should expose these...
|
||
*/
|
||
|
||
var Watcher = void 0;
|
||
function getWatcher(vm) {
|
||
if (!Watcher) {
|
||
var unwatch = vm.$watch('__vuex__', function (a) {
|
||
return a;
|
||
});
|
||
Watcher = vm._watchers[0].constructor;
|
||
unwatch();
|
||
}
|
||
return Watcher;
|
||
}
|
||
|
||
var Dep = void 0;
|
||
function getDep(vm) {
|
||
if (!Dep) {
|
||
Dep = vm._data.__ob__.dep.constructor;
|
||
}
|
||
return Dep;
|
||
}
|
||
|
||
var hook = typeof window !== 'undefined' && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
|
||
|
||
var devtoolMiddleware = {
|
||
onInit: function onInit(state, store) {
|
||
if (!hook) return;
|
||
hook.emit('vuex:init', store);
|
||
hook.on('vuex:travel-to-state', function (targetState) {
|
||
var currentState = store._vm._data;
|
||
store._dispatching = true;
|
||
Object.keys(targetState).forEach(function (key) {
|
||
currentState[key] = targetState[key];
|
||
});
|
||
store._dispatching = false;
|
||
});
|
||
},
|
||
onMutation: function onMutation(mutation, state) {
|
||
if (!hook) return;
|
||
hook.emit('vuex:mutation', mutation, state);
|
||
}
|
||
};
|
||
|
||
function override (Vue) {
|
||
// override init and inject vuex init procedure
|
||
var _init = Vue.prototype._init;
|
||
Vue.prototype._init = function () {
|
||
var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
|
||
|
||
options.init = options.init ? [vuexInit].concat(options.init) : vuexInit;
|
||
_init.call(this, options);
|
||
};
|
||
|
||
function vuexInit() {
|
||
var options = this.$options;
|
||
var store = options.store;
|
||
var vuex = options.vuex;
|
||
// store injection
|
||
|
||
if (store) {
|
||
this.$store = store;
|
||
} else if (options.parent && options.parent.$store) {
|
||
this.$store = options.parent.$store;
|
||
}
|
||
// vuex option handling
|
||
if (vuex) {
|
||
if (!this.$store) {
|
||
console.warn('[vuex] store not injected. make sure to ' + 'provide the store option in your root component.');
|
||
}
|
||
var state = vuex.state;
|
||
var getters = vuex.getters;
|
||
var actions = vuex.actions;
|
||
// handle deprecated state option
|
||
|
||
if (state && !getters) {
|
||
console.warn('[vuex] vuex.state option will been deprecated in 1.0. ' + 'Use vuex.getters instead.');
|
||
getters = state;
|
||
}
|
||
// getters
|
||
if (getters) {
|
||
options.computed = options.computed || {};
|
||
for (var key in getters) {
|
||
defineVuexGetter(this, key, getters[key]);
|
||
}
|
||
}
|
||
// actions
|
||
if (actions) {
|
||
options.methods = options.methods || {};
|
||
for (var _key in actions) {
|
||
options.methods[_key] = makeBoundAction(actions[_key], this.$store);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
function setter() {
|
||
throw new Error('vuex getter properties are read-only.');
|
||
}
|
||
|
||
function defineVuexGetter(vm, key, getter) {
|
||
Object.defineProperty(vm, key, {
|
||
enumerable: true,
|
||
configurable: true,
|
||
get: makeComputedGetter(vm.$store, getter),
|
||
set: setter
|
||
});
|
||
}
|
||
|
||
function makeComputedGetter(store, getter) {
|
||
var id = store._getterCacheId;
|
||
// cached
|
||
if (getter[id]) {
|
||
return getter[id];
|
||
}
|
||
var vm = store._vm;
|
||
var Watcher = getWatcher(vm);
|
||
var Dep = getDep(vm);
|
||
var watcher = new Watcher(vm, function (state) {
|
||
return getter(state);
|
||
}, null, { lazy: true });
|
||
var computedGetter = function computedGetter() {
|
||
if (watcher.dirty) {
|
||
watcher.evaluate();
|
||
}
|
||
if (Dep.target) {
|
||
watcher.depend();
|
||
}
|
||
return watcher.value;
|
||
};
|
||
getter[id] = computedGetter;
|
||
return computedGetter;
|
||
}
|
||
|
||
function makeBoundAction(action, store) {
|
||
return function vuexBoundAction() {
|
||
for (var _len = arguments.length, args = Array(_len), _key2 = 0; _key2 < _len; _key2++) {
|
||
args[_key2] = arguments[_key2];
|
||
}
|
||
|
||
return action.call.apply(action, [this, store].concat(args));
|
||
};
|
||
}
|
||
|
||
// option merging
|
||
var merge = Vue.config.optionMergeStrategies.computed;
|
||
Vue.config.optionMergeStrategies.vuex = function (toVal, fromVal) {
|
||
if (!toVal) return fromVal;
|
||
if (!fromVal) return toVal;
|
||
return {
|
||
getters: merge(toVal.getters, fromVal.getters),
|
||
state: merge(toVal.state, fromVal.state),
|
||
actions: merge(toVal.actions, fromVal.actions)
|
||
};
|
||
};
|
||
}
|
||
|
||
var Vue = void 0;
|
||
var uid = 0;
|
||
|
||
var Store = function () {
|
||
|
||
/**
|
||
* @param {Object} options
|
||
* - {Object} state
|
||
* - {Object} actions
|
||
* - {Object} mutations
|
||
* - {Array} middlewares
|
||
* - {Boolean} strict
|
||
*/
|
||
|
||
function Store() {
|
||
var _this = this;
|
||
|
||
var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
|
||
|
||
var _ref$state = _ref.state;
|
||
var state = _ref$state === undefined ? {} : _ref$state;
|
||
var _ref$mutations = _ref.mutations;
|
||
var mutations = _ref$mutations === undefined ? {} : _ref$mutations;
|
||
var _ref$modules = _ref.modules;
|
||
var modules = _ref$modules === undefined ? {} : _ref$modules;
|
||
var _ref$middlewares = _ref.middlewares;
|
||
var middlewares = _ref$middlewares === undefined ? [] : _ref$middlewares;
|
||
var _ref$strict = _ref.strict;
|
||
var strict = _ref$strict === undefined ? false : _ref$strict;
|
||
babelHelpers.classCallCheck(this, Store);
|
||
|
||
this._getterCacheId = 'vuex_store_' + uid++;
|
||
this._dispatching = false;
|
||
this._rootMutations = this._mutations = mutations;
|
||
this._modules = modules;
|
||
// bind dispatch to self
|
||
var dispatch = this.dispatch;
|
||
this.dispatch = function () {
|
||
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
||
args[_key] = arguments[_key];
|
||
}
|
||
|
||
dispatch.apply(_this, args);
|
||
};
|
||
// use a Vue instance to store the state tree
|
||
// suppress warnings just in case the user has added
|
||
// some funky global mixins
|
||
if (!Vue) {
|
||
throw new Error('[vuex] must call Vue.use(Vuex) before creating a store instance.');
|
||
}
|
||
var silent = Vue.config.silent;
|
||
Vue.config.silent = true;
|
||
this._vm = new Vue({
|
||
data: state
|
||
});
|
||
Vue.config.silent = silent;
|
||
this._setupModuleState(state, modules);
|
||
this._setupModuleMutations(modules);
|
||
this._setupMiddlewares(middlewares, state);
|
||
// add extra warnings in strict mode
|
||
if (strict) {
|
||
this._setupMutationCheck();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Getter for the entire state tree.
|
||
* Read only.
|
||
*
|
||
* @return {Object}
|
||
*/
|
||
|
||
babelHelpers.createClass(Store, [{
|
||
key: 'dispatch',
|
||
|
||
|
||
/**
|
||
* Dispatch an action.
|
||
*
|
||
* @param {String} type
|
||
*/
|
||
|
||
value: function dispatch(type) {
|
||
var _this2 = this;
|
||
|
||
for (var _len2 = arguments.length, payload = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
||
payload[_key2 - 1] = arguments[_key2];
|
||
}
|
||
|
||
// compatibility for object actions, e.g. FSA
|
||
if ((typeof type === 'undefined' ? 'undefined' : babelHelpers.typeof(type)) === 'object' && type.type && arguments.length === 1) {
|
||
payload = [type];
|
||
type = type.type;
|
||
}
|
||
var mutation = this._mutations[type];
|
||
var prevSnapshot = this._prevSnapshot;
|
||
var state = this.state;
|
||
var snapshot = void 0,
|
||
clonedPayload = void 0;
|
||
if (mutation) {
|
||
this._dispatching = true;
|
||
// apply the mutation
|
||
if (Array.isArray(mutation)) {
|
||
mutation.forEach(function (m) {
|
||
return m.apply(undefined, [state].concat(babelHelpers.toConsumableArray(payload)));
|
||
});
|
||
} else {
|
||
mutation.apply(undefined, [state].concat(babelHelpers.toConsumableArray(payload)));
|
||
}
|
||
this._dispatching = false;
|
||
// invoke middlewares
|
||
if (this._needSnapshots) {
|
||
snapshot = this._prevSnapshot = deepClone(state);
|
||
clonedPayload = deepClone(payload);
|
||
}
|
||
this._middlewares.forEach(function (m) {
|
||
if (m.onMutation) {
|
||
if (m.snapshot) {
|
||
m.onMutation({ type: type, payload: clonedPayload }, snapshot, prevSnapshot, _this2);
|
||
} else {
|
||
m.onMutation({ type: type, payload: payload }, state, _this2);
|
||
}
|
||
}
|
||
});
|
||
} else {
|
||
console.warn('[vuex] Unknown mutation: ' + type);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Watch state changes on the store.
|
||
* Same API as Vue's $watch, except when watching a function,
|
||
* the function gets the state as the first argument.
|
||
*
|
||
* @param {String|Function} expOrFn
|
||
* @param {Function} cb
|
||
* @param {Object} [options]
|
||
*/
|
||
|
||
}, {
|
||
key: 'watch',
|
||
value: function watch(expOrFn, cb, options) {
|
||
var _this3 = this;
|
||
|
||
return this._vm.$watch(function () {
|
||
return typeof expOrFn === 'function' ? expOrFn(_this3.state) : _this3._vm.$get(expOrFn);
|
||
}, cb, options);
|
||
}
|
||
|
||
/**
|
||
* Hot update mutations & modules.
|
||
*
|
||
* @param {Object} options
|
||
* - {Object} [mutations]
|
||
* - {Object} [modules]
|
||
*/
|
||
|
||
}, {
|
||
key: 'hotUpdate',
|
||
value: function hotUpdate() {
|
||
var _ref2 = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
|
||
|
||
var mutations = _ref2.mutations;
|
||
var modules = _ref2.modules;
|
||
|
||
this._rootMutations = this._mutations = mutations || this._rootMutations;
|
||
this._setupModuleMutations(modules || this._modules);
|
||
}
|
||
|
||
/**
|
||
* Attach sub state tree of each module to the root tree.
|
||
*
|
||
* @param {Object} state
|
||
* @param {Object} modules
|
||
*/
|
||
|
||
}, {
|
||
key: '_setupModuleState',
|
||
value: function _setupModuleState(state, modules) {
|
||
var setPath = Vue.parsers.path.setPath;
|
||
|
||
Object.keys(modules).forEach(function (key) {
|
||
setPath(state, key, modules[key].state || {});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Bind mutations for each module to its sub tree and
|
||
* merge them all into one final mutations map.
|
||
*
|
||
* @param {Object} updatedModules
|
||
*/
|
||
|
||
}, {
|
||
key: '_setupModuleMutations',
|
||
value: function _setupModuleMutations(updatedModules) {
|
||
var modules = this._modules;
|
||
var getPath = Vue.parsers.path.getPath;
|
||
|
||
var allMutations = [this._rootMutations];
|
||
Object.keys(updatedModules).forEach(function (key) {
|
||
modules[key] = updatedModules[key];
|
||
});
|
||
Object.keys(modules).forEach(function (key) {
|
||
var module = modules[key];
|
||
if (!module || !module.mutations) return;
|
||
// bind mutations to sub state tree
|
||
var mutations = {};
|
||
Object.keys(module.mutations).forEach(function (name) {
|
||
var original = module.mutations[name];
|
||
mutations[name] = function (state) {
|
||
for (var _len3 = arguments.length, args = Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
|
||
args[_key3 - 1] = arguments[_key3];
|
||
}
|
||
|
||
original.apply(undefined, [getPath(state, key)].concat(args));
|
||
};
|
||
});
|
||
allMutations.push(mutations);
|
||
});
|
||
this._mutations = mergeObjects(allMutations);
|
||
}
|
||
|
||
/**
|
||
* Setup mutation check: if the vuex instance's state is mutated
|
||
* outside of a mutation handler, we throw en error. This effectively
|
||
* enforces all mutations to the state to be trackable and hot-reloadble.
|
||
* However, this comes at a run time cost since we are doing a deep
|
||
* watch on the entire state tree, so it is only enalbed with the
|
||
* strict option is set to true.
|
||
*/
|
||
|
||
}, {
|
||
key: '_setupMutationCheck',
|
||
value: function _setupMutationCheck() {
|
||
var _this4 = this;
|
||
|
||
var Watcher = getWatcher(this._vm);
|
||
/* eslint-disable no-new */
|
||
new Watcher(this._vm, '$data', function () {
|
||
if (!_this4._dispatching) {
|
||
throw new Error('[vuex] Do not mutate vuex store state outside mutation handlers.');
|
||
}
|
||
}, { deep: true, sync: true });
|
||
/* eslint-enable no-new */
|
||
}
|
||
|
||
/**
|
||
* Setup the middlewares. The devtools middleware is always
|
||
* included, since it does nothing if no devtool is detected.
|
||
*
|
||
* A middleware can demand the state it receives to be
|
||
* "snapshots", i.e. deep clones of the actual state tree.
|
||
*
|
||
* @param {Array} middlewares
|
||
* @param {Object} state
|
||
*/
|
||
|
||
}, {
|
||
key: '_setupMiddlewares',
|
||
value: function _setupMiddlewares(middlewares, state) {
|
||
var _this5 = this;
|
||
|
||
this._middlewares = [devtoolMiddleware].concat(middlewares);
|
||
this._needSnapshots = middlewares.some(function (m) {
|
||
return m.snapshot;
|
||
});
|
||
if (this._needSnapshots) {
|
||
console.log('[vuex] One or more of your middlewares are taking state snapshots ' + 'for each mutation. Make sure to use them only during development.');
|
||
}
|
||
var initialSnapshot = this._prevSnapshot = this._needSnapshots ? deepClone(state) : null;
|
||
// call init hooks
|
||
this._middlewares.forEach(function (m) {
|
||
if (m.onInit) {
|
||
m.onInit(m.snapshot ? initialSnapshot : state, _this5);
|
||
}
|
||
});
|
||
}
|
||
}, {
|
||
key: 'state',
|
||
get: function get() {
|
||
return this._vm._data;
|
||
},
|
||
set: function set(v) {
|
||
throw new Error('[vuex] Vuex root state is read only.');
|
||
}
|
||
}]);
|
||
return Store;
|
||
}();
|
||
|
||
function install(_Vue) {
|
||
Vue = _Vue;
|
||
override(Vue);
|
||
}
|
||
|
||
// auto install in dist mode
|
||
if (typeof window !== 'undefined' && window.Vue) {
|
||
install(window.Vue);
|
||
}
|
||
|
||
function createLogger() {
|
||
console.warn('[vuex] Vuex.createLogger has been deprecated.' + 'Use `import createLogger from \'vuex/logger\' instead.');
|
||
}
|
||
|
||
var index = {
|
||
Store: Store,
|
||
install: install,
|
||
createLogger: createLogger
|
||
};
|
||
|
||
return index;
|
||
|
||
}));
|
||
}).apply(this, arguments);
|
||
|
||
},{}],154:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("node_modules/yeast/index.js", module);
|
||
(function(){
|
||
'use strict';
|
||
|
||
var alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'.split('')
|
||
, length = 64
|
||
, map = {}
|
||
, seed = 0
|
||
, i = 0
|
||
, prev;
|
||
|
||
/**
|
||
* Return a string representing the specified number.
|
||
*
|
||
* @param {Number} num The number to convert.
|
||
* @returns {String} The string representation of the number.
|
||
* @api public
|
||
*/
|
||
function encode(num) {
|
||
var encoded = '';
|
||
|
||
do {
|
||
encoded = alphabet[num % length] + encoded;
|
||
num = Math.floor(num / length);
|
||
} while (num > 0);
|
||
|
||
return encoded;
|
||
}
|
||
|
||
/**
|
||
* Return the integer value specified by the given string.
|
||
*
|
||
* @param {String} str The string to convert.
|
||
* @returns {Number} The integer value represented by the string.
|
||
* @api public
|
||
*/
|
||
function decode(str) {
|
||
var decoded = 0;
|
||
|
||
for (i = 0; i < str.length; i++) {
|
||
decoded = decoded * length + map[str.charAt(i)];
|
||
}
|
||
|
||
return decoded;
|
||
}
|
||
|
||
/**
|
||
* Yeast: A tiny growing id generator.
|
||
*
|
||
* @returns {String} A unique id.
|
||
* @api public
|
||
*/
|
||
function yeast() {
|
||
var now = encode(+new Date());
|
||
|
||
if (now !== prev) return seed = 0, prev = now;
|
||
return now +'.'+ encode(seed++);
|
||
}
|
||
|
||
//
|
||
// Map each character to its index.
|
||
//
|
||
for (; i < length; i++) map[alphabet[i]] = i;
|
||
|
||
//
|
||
// Expose the `yeast`, `encode` and `decode` functions.
|
||
//
|
||
yeast.encode = encode;
|
||
yeast.decode = decode;
|
||
module.exports = yeast;
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],155:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("src/App.vue", module);
|
||
(function(){
|
||
var __vueify_style__ = require("vueify-insert-css").insert("\n\n/* #F16745 #FFC65D #7BC8A4 #4CC3D9 #93648D #404040 */\n\n body {\n color: #404040;\n }\n\n .jumbotron-top {\n color: #fff;\n background: #4CC3D9;\n margin-bottom: 0;\n }\n\n .btn-custom {\n color: #fff;\n background: #F16745;\n }\n\n .jumbotron.jumbotron-green {\n padding: 75px 0;\n /*background: #404040;*/\n /*color: #fff;*/\n }\n\n #v-select .dropdown-toggle {\n /*border-color:#fff;*/\n background: #fff;\n }\n\n #v-select .dropdown-toggle:after {\n color: #404040;\n }\n\n /* Cyan theme */\n #v-select .selected-tag {\n color: #147688;\n background-color: #d7f3f9;\n border-color: #91ddec;\n }\n\n #v-select.dropdown.open .dropdown-toggle,\n #v-select.dropdown.open .dropdown-menu {\n border-color: #4CC3D9;\n }\n\n #v-select .active a {\n background: rgba(50,50,50,.1);\n color: #333;\n }\n\n #v-select.dropdown .highlight a,\n #v-select.dropdown li:hover a {\n background: #4CC3D9;\n color: #fff;\n }\n\n #output {\n height: 200px;\n border: none;\n color: #404040;\n }\n")
|
||
'use strict';
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
|
||
var _Jumbotron = require('./components/Jumbotron.vue');
|
||
|
||
var _Jumbotron2 = _interopRequireDefault(_Jumbotron);
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
exports.default = {
|
||
components: { Jumbotron: _Jumbotron2.default }
|
||
};
|
||
if (module.exports.__esModule) module.exports = module.exports.default
|
||
;(typeof module.exports === "function"? module.exports.options: module.exports).template = "\n<div class=\"jumbotron jumbotron-top\">\n <div class=\"container\">\n <h1>Vue Select</h1>\n <p class=\"lead\">A simple component that provides similar functionality to Select2 without the overhead of jQuery.</p>\n <a class=\"btn btn-custom\" href=\"https://github.com/sagalbot/vue-select\">View on GitHub</a>\n </div>\n</div>\n\n <jumbotron></jumbotron>\n\n <div id=\"app\" class=\"container\">\n <h2 class=\"page-header\">Live Edit <small>play around with the above vue-select</small></h2>\n\n <div class=\"row\">\n <div class=\"col-md-6\">\n <label class=\"control-label\">Options</label><br>\n <div class=\"radio\">\n <label for=\"advanced\">\n <input id=\"advanced\" type=\"radio\" v-model=\"optionType\" value=\"advanced\"> Objects\n <pre><code class=\"language-javascript\">[{value: 'foo', label: 'Foo'}]</code></pre>\n </label>\n <br>\n <label for=\"simple\">\n <input id=\"simple\" type=\"radio\" v-model=\"optionType\" value=\"simple\"> Strings\n <pre><code class=\"language-javascript\">['foo', 'bar']</code></pre>\n </label>\n <span class=\"help-block\">The <code>options</code> property is watched for changes, and the value is reset anytime the options change. This is useful if you have multiple selection boxes that depend on its ancestors values.</span>\n </div>\n </div>\n\n <div class=\"col-md-6\">\n\n <div class=\"form-group\">\n <label class=\"control-label\">Allow Multiple</label>\n <div class=\"checkbox\">\n <label class=\"control-label\">\n <input v-model=\"multiple\" type=\"checkbox\"> True\n </label>\n <span class=\"help-block\">Equivalent to the <code>multiple</code> attribute to a <code><select></code>. You'll want to clear any selections you have made before changing this option. It's not one that should be changed after render.</span>\n </div>\n </div>\n\n <div class=\"form-group\">\n <label class=\"control-label\">Max Height</label>\n <input type=\"text\" v-model=\"maxHeight\" class=\"form-control\">\n <span class=\"help-block\">Limit the height of the dropdown menu.</span>\n </div>\n\n <div class=\"form-group\">\n <label class=\"control-label\">Placeholder</label>\n <input type=\"text\" v-model=\"placeholder\" class=\"form-control\">\n <span class=\"help-block\">Equivalent to the <code>placeholder</code> attribute.</span>\n </div>\n </div>\n </div>\n\n <div class=\"row\">\n <div class=\"col-md-6\">\n <h2 class=\"page-header\">Install & Usage</h2>\n <h5>Install from GitHub using NPM</h5>\n <pre><code class=\"language-c-like\">$ npm install sagalbot/vue-select</code></pre>\n\n <pre v-pre=\"\"> <code class=\"language-markup\"><template>\n <div id=\"myApp\">\n <v-select :value.sync=\"selected\" :options=\"options\"></v-select>\n </div>\n </template></code>\n\n <code class=\"language-markup\"><script></code>\n <code class=\"language-javascript\">import vSelect from 'vue-select'\n export default {\n components: {vSelect},\n\n data() {\n return {\n selected: null,\n options: ['foo','bar','baz']\n }\n }\n }</code>\n <code class=\"language-markup\"></script></code>\n </pre>\n </div>\n <div class=\"col-md-6\">\n <h2 class=\"page-header\">Parameters</h2>\n <ul>\n <li>\n <code>value</code> Represents the currently selected value(s)\n <ul>\n <li>type: String</li>\n <li>required: true </li>\n </ul>\n </li>\n\n <li>\n <code>options</code> An array of strings or objects to be used as dropdown choices. Supports <code>['foo','bar']</code> & <code>[{label: 'Foo', value: 'foo'}]</code>. When using the <code>[{}]</code> syntax, the objects in the array can have as many properties as you need, as long as the object contains <code>value</code> and <code>label</code> keys.\n <ul>\n <li>type: Array</li>\n <li>default: []</li>\n </ul>\n </li>\n\n <li>\n <code>maxHeight</code> Limit the height of the dropdown menu\n <ul>\n <li>type: String</li>\n <li>default: '400px'</li>\n </ul>\n </li>\n\n <li>\n <code>searchable</code> Toggle filtering of options\n <ul>\n <li>type: Boolean</li>\n <li>default: true</li>\n </ul>\n </li>\n\n <li>\n <code>multiple</code> Equivalent to <code>multiple</code> attribute on a <code><select></code>\n <ul>\n <li>type: Boolean</li>\n <li>default: true</li>\n </ul>\n </li>\n\n <li>\n <code>placeholder</code> Equivalent to <code>placeholder</code> attribute on an <code><input></code>\n <ul>\n <li>type: String</li>\n <li>default: ''</li>\n </ul>\n </li>\n\n <li>\n <code>transition</code> Vue <code>transition</code> prop applied to the <code>.dropdown-menu</code>\n <ul>\n <li>type: Boolean</li>\n <li>default: true</li>\n </ul>\n </li>\n </ul>\n\n </div>\n </div>\n\n</div>\n"
|
||
if (module.hot) {(function () { module.hot.accept()
|
||
var hotAPI = require("vue-hot-reload-api")
|
||
hotAPI.install(require("vue"), true)
|
||
if (!hotAPI.compatible) return
|
||
var id = "/Volumes/Documents/Dropbox/htdocs/vue-select/src/App.vue"
|
||
module.hot.dispose(function () {
|
||
require("vueify-insert-css").cache["\n\n/* #F16745 #FFC65D #7BC8A4 #4CC3D9 #93648D #404040 */\n\n body {\n color: #404040;\n }\n\n .jumbotron-top {\n color: #fff;\n background: #4CC3D9;\n margin-bottom: 0;\n }\n\n .btn-custom {\n color: #fff;\n background: #F16745;\n }\n\n .jumbotron.jumbotron-green {\n padding: 75px 0;\n /*background: #404040;*/\n /*color: #fff;*/\n }\n\n #v-select .dropdown-toggle {\n /*border-color:#fff;*/\n background: #fff;\n }\n\n #v-select .dropdown-toggle:after {\n color: #404040;\n }\n\n /* Cyan theme */\n #v-select .selected-tag {\n color: #147688;\n background-color: #d7f3f9;\n border-color: #91ddec;\n }\n\n #v-select.dropdown.open .dropdown-toggle,\n #v-select.dropdown.open .dropdown-menu {\n border-color: #4CC3D9;\n }\n\n #v-select .active a {\n background: rgba(50,50,50,.1);\n color: #333;\n }\n\n #v-select.dropdown .highlight a,\n #v-select.dropdown li:hover a {\n background: #4CC3D9;\n color: #fff;\n }\n\n #output {\n height: 200px;\n border: none;\n color: #404040;\n }\n"] = false
|
||
document.head.removeChild(__vueify_style__)
|
||
})
|
||
if (!module.hot.data) {
|
||
hotAPI.createRecord(id, module.exports)
|
||
} else {
|
||
hotAPI.update(id, module.exports, (typeof module.exports === "function" ? module.exports.options : module.exports).template)
|
||
}
|
||
})()}
|
||
}).apply(this, arguments);
|
||
|
||
},{"./components/Jumbotron.vue":156,"vue":151,"vue-hot-reload-api":150,"vueify-insert-css":152}],156:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("src/components/Jumbotron.vue", module);
|
||
(function(){
|
||
'use strict';
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
|
||
var _Select = require('./Select.vue');
|
||
|
||
var _Select2 = _interopRequireDefault(_Select);
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
exports.default = {
|
||
components: { vSelect: _Select2.default },
|
||
|
||
data: function data() {
|
||
return {
|
||
select: null,
|
||
placeholder: 'Choose a Country',
|
||
multiple: true,
|
||
maxHeight: '400px',
|
||
options: {
|
||
advanced: require('../countries/countries.js'),
|
||
simple: require('../countries/simpleCountries.js'),
|
||
simpler: [{ label: 'This is Foo', value: 'foo' }, { label: 'This is Bar', value: 'bar' }, { label: 'This is Baz', value: 'baz' }]
|
||
},
|
||
optionType: 'simple'
|
||
};
|
||
}
|
||
};
|
||
if (module.exports.__esModule) module.exports = module.exports.default
|
||
;(typeof module.exports === "function"? module.exports.options: module.exports).template = "\n<div class=\"jumbotron jumbotron-green\">\n <div class=\"container\">\n <div class=\"row\">\n <div class=\"col-md-6 col-md-offset-1\">\n\n <v-select id=\"v-select\" :placeholder=\"placeholder\" :value.sync=\"select\" :options=\"options[optionType]\" :multiple=\"multiple\">\n </v-select>\n\n </div>\n\n <pre id=\"output\" class=\"col-md-4\">{{ select | json }}</pre>\n </div>\n </div>\n</div>\n"
|
||
if (module.hot) {(function () { module.hot.accept()
|
||
var hotAPI = require("vue-hot-reload-api")
|
||
hotAPI.install(require("vue"), true)
|
||
if (!hotAPI.compatible) return
|
||
var id = "/Volumes/Documents/Dropbox/htdocs/vue-select/src/components/Jumbotron.vue"
|
||
if (!module.hot.data) {
|
||
hotAPI.createRecord(id, module.exports)
|
||
} else {
|
||
hotAPI.update(id, module.exports, (typeof module.exports === "function" ? module.exports.options : module.exports).template)
|
||
}
|
||
})()}
|
||
}).apply(this, arguments);
|
||
|
||
},{"../countries/countries.js":158,"../countries/simpleCountries.js":159,"./Select.vue":157,"vue":151,"vue-hot-reload-api":150}],157:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("src/components/Select.vue", module);
|
||
(function(){
|
||
var __vueify_style__ = require("vueify-insert-css").insert("\n.dropdown[_v-3d450ab6] {\n position: relative;\n}\n\n.open .dropdown-toggle[_v-3d450ab6],\n.open .dropdown-menu[_v-3d450ab6] {\n border-color: rgba(60,60,60,.26);\n}\n\n.open-indicator[_v-3d450ab6] {\n position: absolute;\n top: 10px;\n right: 10px;\n display: inline-block;\n cursor: pointer;\n pointer-events: all;\n -webkit-transition: all 150ms cubic-bezier(1.000, -0.115, 0.975, 0.855);\n transition: all 150ms cubic-bezier(1.000, -0.115, 0.975, 0.855);\n -webkit-transition-timing-function: cubic-bezier(1.000, -0.115, 0.975, 0.855);\n transition-timing-function: cubic-bezier(1.000, -0.115, 0.975, 0.855);\n}\n\n.open .open-indicator[_v-3d450ab6] {\n -webkit-transform: rotate(180deg);\n transform: rotate(180deg);\n}\n\n.dropdown-toggle[_v-3d450ab6] {\n display: block;\n padding: 0;\n background: none;\n border: 1px solid rgba(60,60,60,.26);\n border-radius: 4px;\n white-space: normal;\n}\n.searchable .dropdown-toggle[_v-3d450ab6] {\n cursor: text;\n}\n\n.open .dropdown-toggle[_v-3d450ab6] {\n border-bottom: none;\n border-bottom-left-radius: 0;\n border-bottom-right-radius: 0;\n}\n\n.dropdown-menu[_v-3d450ab6] {\n margin: 0;\n width: 100%;\n overflow-y: scroll;\n border-top: none;\n border-top-left-radius: 0;\n border-top-right-radius: 0;\n}\n\n.selected-tag[_v-3d450ab6] {\n color: #333;\n background-color: #f0f0f0;\n border: 1px solid #ccc;\n border-radius: 4px;\n height: 26px;\n margin: 4px 1px 0px 3px;\n padding: 0 0.25em;\n float: left;\n line-height: 1.7em;\n}\n\n.selected-tag .close[_v-3d450ab6] {\n float: none;\n margin-right: 0;\n font-size: 20px;\n}\n\ninput[type=search][_v-3d450ab6],\ninput[type=search][_v-3d450ab6]:focus {\n display: inline-block;\n border: none;\n outline: none;\n margin: 0;\n width: 10em;\n max-width: 100%;\n background: none;\n position: relative;\n box-shadow: none;\n float: left;\n clear: none;\n}\n\ninput[type=search][_v-3d450ab6]:disabled {\n cursor: pointer;\n}\n\nli a[_v-3d450ab6] {\n cursor: pointer;\n}\n\n.active a[_v-3d450ab6] {\n background: rgba(50,50,50,.1);\n color: #333;\n}\n\n.highlight a[_v-3d450ab6],\nli:hover a[_v-3d450ab6] {\n background: #f0f0f0;\n color: #333;\n}\n")
|
||
'use strict';
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
|
||
var _typeof2 = require('babel-runtime/helpers/typeof');
|
||
|
||
var _typeof3 = _interopRequireDefault(_typeof2);
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
exports.default = {
|
||
props: {
|
||
value: {
|
||
twoway: true,
|
||
required: true
|
||
},
|
||
options: {
|
||
type: Array,
|
||
default: function _default() {
|
||
return [];
|
||
}
|
||
},
|
||
maxHeight: {
|
||
type: String,
|
||
default: '400px'
|
||
},
|
||
searchable: {
|
||
type: Boolean,
|
||
default: true
|
||
},
|
||
multiple: {
|
||
type: Boolean,
|
||
default: false
|
||
},
|
||
placeholder: {
|
||
type: String,
|
||
default: ''
|
||
},
|
||
transition: {
|
||
type: String,
|
||
default: 'expand'
|
||
},
|
||
clearSearchOnSelect: {
|
||
type: Boolean,
|
||
default: true
|
||
}
|
||
},
|
||
|
||
data: function data() {
|
||
return {
|
||
search: '',
|
||
open: false,
|
||
typeAheadPointer: -1
|
||
};
|
||
},
|
||
|
||
|
||
watch: {
|
||
options: function options() {
|
||
this.$set('value', this.multiple ? [] : null);
|
||
},
|
||
multiple: function multiple(val) {
|
||
this.$set('value', val ? [] : null);
|
||
},
|
||
filteredOptions: function filteredOptions() {
|
||
this.typeAheadPointer = 0;
|
||
}
|
||
},
|
||
|
||
methods: {
|
||
select: function select(option) {
|
||
if (!this.isOptionSelected(option)) {
|
||
if (this.multiple) {
|
||
|
||
if (!this.value) {
|
||
this.$set('value', [option]);
|
||
} else {
|
||
this.value.push(option);
|
||
}
|
||
} else {
|
||
this.value = option;
|
||
}
|
||
} else {
|
||
if (this.multiple) {
|
||
this.value.$remove(option);
|
||
}
|
||
}
|
||
|
||
if (!this.multiple) {
|
||
this.open = !this.open;
|
||
}
|
||
|
||
if (this.clearSearchOnSelect) {
|
||
this.search = '';
|
||
}
|
||
},
|
||
toggleDropdown: function toggleDropdown(e) {
|
||
if (e.target === this.$els.openIndicator || e.target === this.$els.search || e.target === this.$els.toggle || e.target === this.$el) {
|
||
if (this.open) {
|
||
this.$els.search.blur(); // dropdown will close on blur
|
||
} else {
|
||
this.open = true;
|
||
this.$els.search.focus();
|
||
}
|
||
}
|
||
},
|
||
isOptionSelected: function isOptionSelected(option) {
|
||
if (this.multiple && this.value) {
|
||
return this.value.indexOf(option) !== -1;
|
||
}
|
||
|
||
return this.value === option;
|
||
},
|
||
getOptionValue: function getOptionValue(option) {
|
||
if ((typeof option === 'undefined' ? 'undefined' : (0, _typeof3.default)(option)) === 'object' && option.value) {
|
||
return option.value;
|
||
}
|
||
|
||
return option;
|
||
},
|
||
getOptionLabel: function getOptionLabel(option) {
|
||
if ((typeof option === 'undefined' ? 'undefined' : (0, _typeof3.default)(option)) === 'object' && option.label) {
|
||
return option.label;
|
||
}
|
||
|
||
return option;
|
||
},
|
||
typeAheadUp: function typeAheadUp() {
|
||
if (this.typeAheadPointer > 0) this.typeAheadPointer--;
|
||
},
|
||
typeAheadDown: function typeAheadDown() {
|
||
if (this.typeAheadPointer < this.filteredOptions.length - 1) this.typeAheadPointer++;
|
||
},
|
||
typeAheadSelect: function typeAheadSelect() {
|
||
if (this.filteredOptions[this.typeAheadPointer]) {
|
||
this.select(this.filteredOptions[this.typeAheadPointer]);
|
||
}
|
||
|
||
if (this.clearSearchOnSelect) {
|
||
this.search = "";
|
||
}
|
||
},
|
||
onEscape: function onEscape() {
|
||
if (!this.search.length) {
|
||
this.$els.search.blur();
|
||
} else {
|
||
this.$set('search', '');
|
||
}
|
||
},
|
||
maybeDeleteValue: function maybeDeleteValue() {
|
||
if (!this.$els.search.value.length && this.value) {
|
||
return this.multiple ? this.value.pop() : this.$set('value', null);
|
||
}
|
||
}
|
||
},
|
||
|
||
computed: {
|
||
cssClasses: function cssClasses() {
|
||
return {
|
||
open: this.open,
|
||
searchable: this.searchable
|
||
};
|
||
},
|
||
searchPlaceholder: function searchPlaceholder() {
|
||
if (this.isValueEmpty && this.placeholder) {
|
||
return this.placeholder;
|
||
}
|
||
},
|
||
filteredOptions: function filteredOptions() {
|
||
return this.$options.filters.filterBy(this.options, this.search);
|
||
},
|
||
isValueEmpty: function isValueEmpty() {
|
||
if (this.value) {
|
||
return !this.value.length;
|
||
}
|
||
|
||
return true;
|
||
},
|
||
valueAsArray: function valueAsArray() {
|
||
if (this.multiple) {
|
||
return this.value;
|
||
} else if (this.value) {
|
||
return [this.value];
|
||
}
|
||
|
||
return [];
|
||
}
|
||
}
|
||
|
||
};
|
||
if (module.exports.__esModule) module.exports = module.exports.default
|
||
;(typeof module.exports === "function"? module.exports.options: module.exports).template = "\n<div class=\"dropdown\" :class=\"cssClasses\" _v-3d450ab6=\"\">\n <div v-el:toggle=\"\" @mousedown.prevent=\"toggleDropdown\" class=\"dropdown-toggle clearfix\" type=\"button\" _v-3d450ab6=\"\">\n <span class=\"form-control\" v-if=\"!searchable && isValueEmpty\" _v-3d450ab6=\"\">\n {{ placeholder }}\n </span>\n\n <span class=\"selected-tag\" v-for=\"option in valueAsArray\" _v-3d450ab6=\"\">\n {{ getOptionLabel(option) }}\n <button v-if=\"multiple\" @click=\"select(option)\" type=\"button\" class=\"close\" _v-3d450ab6=\"\">\n <span aria-hidden=\"true\" _v-3d450ab6=\"\">×</span>\n </button>\n </span>\n\n <input v-el:search=\"\" v-show=\"searchable\" v-model=\"search\" @keydown.delete=\"maybeDeleteValue\" @keydown.esc=\"onEscape\" @keydown.up.prevent=\"typeAheadUp\" @keydown.down.prevent=\"typeAheadDown\" @keydown.enter.prevent=\"typeAheadSelect\" @blur=\"open = false\" @focus=\"open = true\" type=\"search\" class=\"form-control\" :placeholder=\"searchPlaceholder\" _v-3d450ab6=\"\">\n\n <i v-el:open-indicator=\"\" role=\"presentation\" class=\"open-indicator glyphicon-chevron-down glyphicon\" _v-3d450ab6=\"\"></i>\n </div>\n\n <ul v-show=\"open\" v-el:dropdown-menu=\"\" :transition=\"transition\" :style=\"{ 'max-height': maxHeight }\" class=\"dropdown-menu animated\" _v-3d450ab6=\"\">\n <li v-for=\"option in filteredOptions\" :class=\"{ active: isOptionSelected(option), highlight: $index === typeAheadPointer }\" @mouseover=\"typeAheadPointer = $index\" _v-3d450ab6=\"\">\n <a @mousedown.prevent=\"select(option)\" _v-3d450ab6=\"\">\n {{ getOptionLabel(option) }}\n </a>\n </li>\n <li transition=\"fade\" v-if=\"!filteredOptions.length\" class=\"divider\" _v-3d450ab6=\"\"></li>\n <li transition=\"fade\" v-if=\"!filteredOptions.length\" class=\"text-center\" _v-3d450ab6=\"\">Sorry, no matching options.</li>\n </ul>\n</div>\n"
|
||
if (module.hot) {(function () { module.hot.accept()
|
||
var hotAPI = require("vue-hot-reload-api")
|
||
hotAPI.install(require("vue"), true)
|
||
if (!hotAPI.compatible) return
|
||
var id = "/Volumes/Documents/Dropbox/htdocs/vue-select/src/components/Select.vue"
|
||
module.hot.dispose(function () {
|
||
require("vueify-insert-css").cache["\n.dropdown[_v-3d450ab6] {\n position: relative;\n}\n\n.open .dropdown-toggle[_v-3d450ab6],\n.open .dropdown-menu[_v-3d450ab6] {\n border-color: rgba(60,60,60,.26);\n}\n\n.open-indicator[_v-3d450ab6] {\n position: absolute;\n top: 10px;\n right: 10px;\n display: inline-block;\n cursor: pointer;\n pointer-events: all;\n -webkit-transition: all 150ms cubic-bezier(1.000, -0.115, 0.975, 0.855);\n transition: all 150ms cubic-bezier(1.000, -0.115, 0.975, 0.855);\n -webkit-transition-timing-function: cubic-bezier(1.000, -0.115, 0.975, 0.855);\n transition-timing-function: cubic-bezier(1.000, -0.115, 0.975, 0.855);\n}\n\n.open .open-indicator[_v-3d450ab6] {\n -webkit-transform: rotate(180deg);\n transform: rotate(180deg);\n}\n\n.dropdown-toggle[_v-3d450ab6] {\n display: block;\n padding: 0;\n background: none;\n border: 1px solid rgba(60,60,60,.26);\n border-radius: 4px;\n white-space: normal;\n}\n.searchable .dropdown-toggle[_v-3d450ab6] {\n cursor: text;\n}\n\n.open .dropdown-toggle[_v-3d450ab6] {\n border-bottom: none;\n border-bottom-left-radius: 0;\n border-bottom-right-radius: 0;\n}\n\n.dropdown-menu[_v-3d450ab6] {\n margin: 0;\n width: 100%;\n overflow-y: scroll;\n border-top: none;\n border-top-left-radius: 0;\n border-top-right-radius: 0;\n}\n\n.selected-tag[_v-3d450ab6] {\n color: #333;\n background-color: #f0f0f0;\n border: 1px solid #ccc;\n border-radius: 4px;\n height: 26px;\n margin: 4px 1px 0px 3px;\n padding: 0 0.25em;\n float: left;\n line-height: 1.7em;\n}\n\n.selected-tag .close[_v-3d450ab6] {\n float: none;\n margin-right: 0;\n font-size: 20px;\n}\n\ninput[type=search][_v-3d450ab6],\ninput[type=search][_v-3d450ab6]:focus {\n display: inline-block;\n border: none;\n outline: none;\n margin: 0;\n width: 10em;\n max-width: 100%;\n background: none;\n position: relative;\n box-shadow: none;\n float: left;\n clear: none;\n}\n\ninput[type=search][_v-3d450ab6]:disabled {\n cursor: pointer;\n}\n\nli a[_v-3d450ab6] {\n cursor: pointer;\n}\n\n.active a[_v-3d450ab6] {\n background: rgba(50,50,50,.1);\n color: #333;\n}\n\n.highlight a[_v-3d450ab6],\nli:hover a[_v-3d450ab6] {\n background: #f0f0f0;\n color: #333;\n}\n"] = false
|
||
document.head.removeChild(__vueify_style__)
|
||
})
|
||
if (!module.hot.data) {
|
||
hotAPI.createRecord(id, module.exports)
|
||
} else {
|
||
hotAPI.update(id, module.exports, (typeof module.exports === "function" ? module.exports.options : module.exports).template)
|
||
}
|
||
})()}
|
||
}).apply(this, arguments);
|
||
|
||
},{"babel-runtime/helpers/typeof":5,"vue":151,"vue-hot-reload-api":150,"vueify-insert-css":152}],158:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("src/countries/countries.js", module);
|
||
(function(){
|
||
"use strict";
|
||
|
||
module.exports = [{ value: "AF", label: "Afghanistan" }, { value: "AX", label: "Åland Islands" }, { value: "AL", label: "Albania" }, { value: "DZ", label: "Algeria" }, { value: "AS", label: "American Samoa" }, { value: "AD", label: "Andorra" }, { value: "AO", label: "Angola" }, { value: "AI", label: "Anguilla" }, { value: "AQ", label: "Antarctica" }, { value: "AG", label: "Antigua and Barbuda" }, { value: "AR", label: "Argentina" }, { value: "AM", label: "Armenia" }, { value: "AW", label: "Aruba" }, { value: "AU", label: "Australia" }, { value: "AT", label: "Austria" }, { value: "AZ", label: "Azerbaijan" }, { value: "BS", label: "Bahamas" }, { value: "BH", label: "Bahrain" }, { value: "BD", label: "Bangladesh" }, { value: "BB", label: "Barbados" }, { value: "BY", label: "Belarus" }, { value: "BE", label: "Belgium" }, { value: "BZ", label: "Belize" }, { value: "BJ", label: "Benin" }, { value: "BM", label: "Bermuda" }, { value: "BT", label: "Bhutan" }, { value: "BO", label: "Bolivia" }, { value: "BA", label: "Bosnia and Herzegovina" }, { value: "BW", label: "Botswana" }, { value: "BV", label: "Bouvet Island" }, { value: "BR", label: "Brazil" }, { value: "IO", label: "British Indian Ocean Territory" }, { value: "BN", label: "Brunei Darussalam" }, { value: "BG", label: "Bulgaria" }, { value: "BF", label: "Burkina Faso" }, { value: "BI", label: "Burundi" }, { value: "KH", label: "Cambodia" }, { value: "CM", label: "Cameroon" }, { value: "CA", label: "Canada" }, { value: "CV", label: "Cape Verde" }, { value: "KY", label: "Cayman Islands" }, { value: "CF", label: "Central African Republic" }, { value: "TD", label: "Chad" }, { value: "CL", label: "Chile" }, { value: "CN", label: "China" }, { value: "CX", label: "Christmas Island" }, { value: "CC", label: "Cocos (Keeling) Islands" }, { value: "CO", label: "Colombia" }, { value: "KM", label: "Comoros" }, { value: "CG", label: "Congo" }, { value: "CD", label: "Congo, The Democratic Republic of The" }, { value: "CK", label: "Cook Islands" }, { value: "CR", label: "Costa Rica" }, { value: "CI", label: "Cote D'ivoire" }, { value: "HR", label: "Croatia" }, { value: "CU", label: "Cuba" }, { value: "CY", label: "Cyprus" }, { value: "CZ", label: "Czech Republic" }, { value: "DK", label: "Denmark" }, { value: "DJ", label: "Djibouti" }, { value: "DM", label: "Dominica" }, { value: "DO", label: "Dominican Republic" }, { value: "EC", label: "Ecuador" }, { value: "EG", label: "Egypt" }, { value: "SV", label: "El Salvador" }, { value: "GQ", label: "Equatorial Guinea" }, { value: "ER", label: "Eritrea" }, { value: "EE", label: "Estonia" }, { value: "ET", label: "Ethiopia" }, { value: "FK", label: "Falkland Islands (Malvinas)" }, { value: "FO", label: "Faroe Islands" }, { value: "FJ", label: "Fiji" }, { value: "FI", label: "Finland" }, { value: "FR", label: "France" }, { value: "GF", label: "French Guiana" }, { value: "PF", label: "French Polynesia" }, { value: "TF", label: "French Southern Territories" }, { value: "GA", label: "Gabon" }, { value: "GM", label: "Gambia" }, { value: "GE", label: "Georgia" }, { value: "DE", label: "Germany" }, { value: "GH", label: "Ghana" }, { value: "GI", label: "Gibraltar" }, { value: "GR", label: "Greece" }, { value: "GL", label: "Greenland" }, { value: "GD", label: "Grenada" }, { value: "GP", label: "Guadeloupe" }, { value: "GU", label: "Guam" }, { value: "GT", label: "Guatemala" }, { value: "GG", label: "Guernsey" }, { value: "GN", label: "Guinea" }, { value: "GW", label: "Guinea-bissau" }, { value: "GY", label: "Guyana" }, { value: "HT", label: "Haiti" }, { value: "HM", label: "Heard Island and Mcdonald Islands" }, { value: "VA", label: "Holy See (Vatican City State)" }, { value: "HN", label: "Honduras" }, { value: "HK", label: "Hong Kong" }, { value: "HU", label: "Hungary" }, { value: "IS", label: "Iceland" }, { value: "IN", label: "India" }, { value: "ID", label: "Indonesia" }, { value: "IR", label: "Iran, Islamic Republic of" }, { value: "IQ", label: "Iraq" }, { value: "IE", label: "Ireland" }, { value: "IM", label: "Isle of Man" }, { value: "IL", label: "Israel" }, { value: "IT", label: "Italy" }, { value: "JM", label: "Jamaica" }, { value: "JP", label: "Japan" }, { value: "JE", label: "Jersey" }, { value: "JO", label: "Jordan" }, { value: "KZ", label: "Kazakhstan" }, { value: "KE", label: "Kenya" }, { value: "KI", label: "Kiribati" }, { value: "KP", label: "Korea, Democratic People's Republic of" }, { value: "KR", label: "Korea, Republic of" }, { value: "KW", label: "Kuwait" }, { value: "KG", label: "Kyrgyzstan" }, { value: "LA", label: "Lao People's Democratic Republic" }, { value: "LV", label: "Latvia" }, { value: "LB", label: "Lebanon" }, { value: "LS", label: "Lesotho" }, { value: "LR", label: "Liberia" }, { value: "LY", label: "Libyan Arab Jamahiriya" }, { value: "LI", label: "Liechtenstein" }, { value: "LT", label: "Lithuania" }, { value: "LU", label: "Luxembourg" }, { value: "MO", label: "Macao" }, { value: "MK", label: "Macedonia, The Former Yugoslav Republic of" }, { value: "MG", label: "Madagascar" }, { value: "MW", label: "Malawi" }, { value: "MY", label: "Malaysia" }, { value: "MV", label: "Maldives" }, { value: "ML", label: "Mali" }, { value: "MT", label: "Malta" }, { value: "MH", label: "Marshall Islands" }, { value: "MQ", label: "Martinique" }, { value: "MR", label: "Mauritania" }, { value: "MU", label: "Mauritius" }, { value: "YT", label: "Mayotte" }, { value: "MX", label: "Mexico" }, { value: "FM", label: "Micronesia, Federated States of" }, { value: "MD", label: "Moldova, Republic of" }, { value: "MC", label: "Monaco" }, { value: "MN", label: "Mongolia" }, { value: "ME", label: "Montenegro" }, { value: "MS", label: "Montserrat" }, { value: "MA", label: "Morocco" }, { value: "MZ", label: "Mozambique" }, { value: "MM", label: "Myanmar" }, { value: "NA", label: "Namibia" }, { value: "NR", label: "Nauru" }, { value: "NP", label: "Nepal" }, { value: "NL", label: "Netherlands" }, { value: "AN", label: "Netherlands Antilles" }, { value: "NC", label: "New Caledonia" }, { value: "NZ", label: "New Zealand" }, { value: "NI", label: "Nicaragua" }, { value: "NE", label: "Niger" }, { value: "NG", label: "Nigeria" }, { value: "NU", label: "Niue" }, { value: "NF", label: "Norfolk Island" }, { value: "MP", label: "Northern Mariana Islands" }, { value: "NO", label: "Norway" }, { value: "OM", label: "Oman" }, { value: "PK", label: "Pakistan" }, { value: "PW", label: "Palau" }, { value: "PS", label: "Palestinian Territory, Occupied" }, { value: "PA", label: "Panama" }, { value: "PG", label: "Papua New Guinea" }, { value: "PY", label: "Paraguay" }, { value: "PE", label: "Peru" }, { value: "PH", label: "Philippines" }, { value: "PN", label: "Pitcairn" }, { value: "PL", label: "Poland" }, { value: "PT", label: "Portugal" }, { value: "PR", label: "Puerto Rico" }, { value: "QA", label: "Qatar" }, { value: "RE", label: "Reunion" }, { value: "RO", label: "Romania" }, { value: "RU", label: "Russian Federation" }, { value: "RW", label: "Rwanda" }, { value: "SH", label: "Saint Helena" }, { value: "KN", label: "Saint Kitts and Nevis" }, { value: "LC", label: "Saint Lucia" }, { value: "PM", label: "Saint Pierre and Miquelon" }, { value: "VC", label: "Saint Vincent and The Grenadines" }, { value: "WS", label: "Samoa" }, { value: "SM", label: "San Marino" }, { value: "ST", label: "Sao Tome and Principe" }, { value: "SA", label: "Saudi Arabia" }, { value: "SN", label: "Senegal" }, { value: "RS", label: "Serbia" }, { value: "SC", label: "Seychelles" }, { value: "SL", label: "Sierra Leone" }, { value: "SG", label: "Singapore" }, { value: "SK", label: "Slovakia" }, { value: "SI", label: "Slovenia" }, { value: "SB", label: "Solomon Islands" }, { value: "SO", label: "Somalia" }, { value: "ZA", label: "South Africa" }, { value: "GS", label: "South Georgia and The South Sandwich Islands" }, { value: "ES", label: "Spain" }, { value: "LK", label: "Sri Lanka" }, { value: "SD", label: "Sudan" }, { value: "SR", label: "Suriname" }, { value: "SJ", label: "Svalbard and Jan Mayen" }, { value: "SZ", label: "Swaziland" }, { value: "SE", label: "Sweden" }, { value: "CH", label: "Switzerland" }, { value: "SY", label: "Syrian Arab Republic" }, { value: "TW", label: "Taiwan, Province of China" }, { value: "TJ", label: "Tajikistan" }, { value: "TZ", label: "Tanzania, United Republic of" }, { value: "TH", label: "Thailand" }, { value: "TL", label: "Timor-leste" }, { value: "TG", label: "Togo" }, { value: "TK", label: "Tokelau" }, { value: "TO", label: "Tonga" }, { value: "TT", label: "Trinidad and Tobago" }, { value: "TN", label: "Tunisia" }, { value: "TR", label: "Turkey" }, { value: "TM", label: "Turkmenistan" }, { value: "TC", label: "Turks and Caicos Islands" }, { value: "TV", label: "Tuvalu" }, { value: "UG", label: "Uganda" }, { value: "UA", label: "Ukraine" }, { value: "AE", label: "United Arab Emirates" }, { value: "GB", label: "United Kingdom" }, { value: "US", label: "United States" }, { value: "UM", label: "United States Minor Outlying Islands" }, { value: "UY", label: "Uruguay" }, { value: "UZ", label: "Uzbekistan" }, { value: "VU", label: "Vanuatu" }, { value: "VE", label: "Venezuela" }, { value: "VN", label: "Viet Nam" }, { value: "VG", label: "Virgin Islands, British" }, { value: "VI", label: "Virgin Islands, U.S." }, { value: "WF", label: "Wallis and Futuna" }, { value: "EH", label: "Western Sahara" }, { value: "YE", label: "Yemen" }, { value: "ZM", label: "Zambia" }, { value: "ZW", label: "Zimbabwe" }];
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],159:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("src/countries/simpleCountries.js", module);
|
||
(function(){
|
||
"use strict";
|
||
|
||
module.exports = ["Afghanistan", "Åland Islands", "Albania", "Algeria", "American Samoa", "Andorra", "Angola", "Anguilla", "Antarctica", "Antigua and Barbuda", "Argentina", "Armenia", "Aruba", "Australia", "Austria", "Azerbaijan", "Bahamas", "Bahrain", "Bangladesh", "Barbados", "Belarus", "Belgium", "Belize", "Benin", "Bermuda", "Bhutan", "Bolivia", "Bosnia and Herzegovina", "Botswana", "Bouvet Island", "Brazil", "British Indian Ocean Territory", "Brunei Darussalam", "Bulgaria", "Burkina Faso", "Burundi", "Cambodia", "Cameroon", "Canada", "Cape Verde", "Cayman Islands", "Central African Republic", "Chad", "Chile", "China", "Christmas Island", "Cocos (Keeling) Islands", "Colombia", "Comoros", "Congo", "Congo, The Democratic Republic of The", "Cook Islands", "Costa Rica", "Cote D'ivoire", "Croatia", "Cuba", "Cyprus", "Czech Republic", "Denmark", "Djibouti", "Dominica", "Dominican Republic", "Ecuador", "Egypt", "El Salvador", "Equatorial Guinea", "Eritrea", "Estonia", "Ethiopia", "Falkland Islands (Malvinas)", "Faroe Islands", "Fiji", "Finland", "France", "French Guiana", "French Polynesia", "French Southern Territories", "Gabon", "Gambia", "Georgia", "Germany", "Ghana", "Gibraltar", "Greece", "Greenland", "Grenada", "Guadeloupe", "Guam", "Guatemala", "Guernsey", "Guinea", "Guinea-bissau", "Guyana", "Haiti", "Heard Island and Mcdonald Islands", "Holy See (Vatican City State)", "Honduras", "Hong Kong", "Hungary", "Iceland", "India", "Indonesia", "Iran, Islamic Republic of", "Iraq", "Ireland", "Isle of Man", "Israel", "Italy", "Jamaica", "Japan", "Jersey", "Jordan", "Kazakhstan", "Kenya", "Kiribati", "Korea, Democratic People's Republic of", "Korea, Republic of", "Kuwait", "Kyrgyzstan", "Lao People's Democratic Republic", "Latvia", "Lebanon", "Lesotho", "Liberia", "Libyan Arab Jamahiriya", "Liechtenstein", "Lithuania", "Luxembourg", "Macao", "Macedonia, The Former Yugoslav Republic of", "Madagascar", "Malawi", "Malaysia", "Maldives", "Mali", "Malta", "Marshall Islands", "Martinique", "Mauritania", "Mauritius", "Mayotte", "Mexico", "Micronesia, Federated States of", "Moldova, Republic of", "Monaco", "Mongolia", "Montenegro", "Montserrat", "Morocco", "Mozambique", "Myanmar", "Namibia", "Nauru", "Nepal", "Netherlands", "Netherlands Antilles", "New Caledonia", "New Zealand", "Nicaragua", "Niger", "Nigeria", "Niue", "Norfolk Island", "Northern Mariana Islands", "Norway", "Oman", "Pakistan", "Palau", "Palestinian Territory, Occupied", "Panama", "Papua New Guinea", "Paraguay", "Peru", "Philippines", "Pitcairn", "Poland", "Portugal", "Puerto Rico", "Qatar", "Reunion", "Romania", "Russian Federation", "Rwanda", "Saint Helena", "Saint Kitts and Nevis", "Saint Lucia", "Saint Pierre and Miquelon", "Saint Vincent and The Grenadines", "Samoa", "San Marino", "Sao Tome and Principe", "Saudi Arabia", "Senegal", "Serbia", "Seychelles", "Sierra Leone", "Singapore", "Slovakia", "Slovenia", "Solomon Islands", "Somalia", "South Africa", "South Georgia and The South Sandwich Islands", "Spain", "Sri Lanka", "Sudan", "Suriname", "Svalbard and Jan Mayen", "Swaziland", "Sweden", "Switzerland", "Syrian Arab Republic", "Taiwan, Province of China", "Tajikistan", "Tanzania, United Republic of", "Thailand", "Timor-leste", "Togo", "Tokelau", "Tonga", "Trinidad and Tobago", "Tunisia", "Turkey", "Turkmenistan", "Turks and Caicos Islands", "Tuvalu", "Uganda", "Ukraine", "United Arab Emirates", "United Kingdom", "United States", "United States Minor Outlying Islands", "Uruguay", "Uzbekistan", "Vanuatu", "Venezuela", "Viet Nam", "Virgin Islands, British", "Virgin Islands, U.S.", "Wallis and Futuna", "Western Sahara", "Yemen", "Zambia", "Zimbabwe"];
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{}],160:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("src/main.js", module);
|
||
(function(){
|
||
'use strict';
|
||
|
||
var _vue = require('vue');
|
||
|
||
var _vue2 = _interopRequireDefault(_vue);
|
||
|
||
var _App = require('./App.vue');
|
||
|
||
var _App2 = _interopRequireDefault(_App);
|
||
|
||
var _store = require('./vuex/store');
|
||
|
||
var _store2 = _interopRequireDefault(_store);
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
/* eslint-disable no-new */
|
||
new _vue2.default({
|
||
el: 'body',
|
||
store: _store2.default,
|
||
components: { App: _App2.default }
|
||
});
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"./App.vue":155,"./vuex/store":161,"vue":151}],161:[function(require,module,exports){
|
||
_hmr["websocket:null"].initModule("src/vuex/store.js", module);
|
||
(function(){
|
||
'use strict';
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
|
||
var _vue = require('vue');
|
||
|
||
var _vue2 = _interopRequireDefault(_vue);
|
||
|
||
var _vuex = require('vuex');
|
||
|
||
var _vuex2 = _interopRequireDefault(_vuex);
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
_vue2.default.use(_vuex2.default);
|
||
_vue2.default.config.debug = true;
|
||
|
||
var state = {
|
||
count: 0
|
||
};
|
||
|
||
var mutations = {
|
||
INCREMENT: function INCREMENT(state) {
|
||
state.count++;
|
||
},
|
||
DECREMENT: function DECREMENT(state) {
|
||
state.count--;
|
||
}
|
||
};
|
||
|
||
exports.default = new _vuex2.default.Store({
|
||
state: state,
|
||
mutations: mutations
|
||
});
|
||
|
||
}).apply(this, arguments);
|
||
|
||
},{"vue":151,"vuex":153}],1:[function(require,module,exports){
|
||
(function(global, _main, moduleDefs, cachedModules, _entries) {
|
||
'use strict';
|
||
|
||
var moduleMeta = {"node_modules/browserify-hmr/lib/has.js":{"index":11,"hash":"Hky4QYVrU1+kFHIEuxPy","parents":["node_modules/browserify-hmr/lib/str-set.js","node_modules/browserify-hmr/inc/index.js"]},"node_modules/process/browser.js":{"index":137,"hash":"d/Dio43QDX3Xt7NYvbr6","parents":["node_modules/vue/dist/vue.common.js"]},"node_modules/vue/dist/vue.common.js":{"index":151,"hash":"1Vqz8fxmKHSuo/7YEUpo","parents":["src/components/Select.vue","src/components/Jumbotron.vue","src/App.vue","src/vuex/store.js","src/main.js"]},"node_modules/parseuri/index.js":{"index":136,"hash":"c/c7XftSI6ClFc9h2jOh","parents":["node_modules/socket.io-client/lib/url.js","node_modules/engine.io-client/lib/socket.js"]},"node_modules/socket.io-client/lib/url.js":{"index":142,"hash":"eA2ffpU7mjSLlYTvz6k0","parents":["node_modules/socket.io-client/lib/index.js"]},"node_modules/debug/browser.js":{"index":46,"hash":"S76q28f1VPJIcCtJn1eq","parents":["node_modules/socket.io-client/lib/url.js","node_modules/socket.io-client/lib/socket.js","node_modules/socket.io-parser/index.js","node_modules/engine.io-client/lib/transports/websocket.js","node_modules/engine.io-client/lib/transports/polling.js","node_modules/engine.io-client/lib/transports/polling-xhr.js","node_modules/engine.io-client/lib/socket.js","node_modules/socket.io-client/lib/manager.js","node_modules/socket.io-client/lib/index.js"]},"node_modules/socket.io-client/lib/on.js":{"index":140,"hash":"y5MOoFpTKKBHwE8q8jae","parents":["node_modules/socket.io-client/lib/socket.js","node_modules/socket.io-client/lib/manager.js"]},"node_modules/socket.io-client/node_modules/component-emitter/index.js":{"index":143,"hash":"asxNeKKEYmnxnAxICTS6","parents":["node_modules/socket.io-client/lib/socket.js","node_modules/socket.io-client/lib/manager.js"]},"node_modules/component-bind/index.js":{"index":13,"hash":"4yIcVw+afwUsnTQyI0a3","parents":["node_modules/socket.io-client/lib/socket.js","node_modules/socket.io-client/lib/manager.js"]},"node_modules/to-array/index.js":{"index":148,"hash":"2EoggafxX+GLXkXiaGjm","parents":["node_modules/socket.io-client/lib/socket.js"]},"node_modules/socket.io-parser/is-buffer.js":{"index":146,"hash":"F42/EWSzWcL1IvKh+yw4","parents":["node_modules/socket.io-parser/binary.js","node_modules/socket.io-parser/index.js"]},"node_modules/isarray/index.js":{"index":64,"hash":"dKtews1S4sHvaZhZ+ceq","parents":["node_modules/has-binary/index.js","node_modules/socket.io-parser/binary.js","node_modules/socket.io-parser/index.js","node_modules/engine.io-parser/node_modules/has-binary/index.js"]},"node_modules/component-emitter/index.js":{"index":14,"hash":"0uL1LSa/mOj+Llu+HTZ7","parents":["node_modules/socket.io-parser/index.js","node_modules/engine.io-client/lib/transport.js","node_modules/engine.io-client/lib/transports/polling-xhr.js","node_modules/engine.io-client/lib/socket.js"]},"node_modules/socket.io-parser/node_modules/json3/lib/json3.js":{"index":147,"hash":"nN5GuS/Ch9onUpX4WT08","parents":["node_modules/socket.io-parser/index.js"]},"node_modules/backo2/index.js":{"index":6,"hash":"L5ry3mfVEw1wgmx9Sa+q","parents":["node_modules/socket.io-client/lib/manager.js"]},"node_modules/indexof/index.js":{"index":63,"hash":"8zMGV0j0ID5bUIeT7r+M","parents":["node_modules/engine.io-client/lib/socket.js","node_modules/socket.io-client/lib/manager.js"]},"node_modules/browserify-hmr/lib/str-set.js":{"index":12,"hash":"lcrDmQK4uaqOqN+FV4/9","parents":["node_modules/browserify-hmr/inc/index.js"]},"node_modules/lodash/internal/arrayFilter.js":{"index":73,"hash":"BGunz0w1QzJXyqQSOdZb","parents":["node_modules/lodash/collection/filter.js"]},"node_modules/lodash/internal/arraySome.js":{"index":75,"hash":"GxeJPxJj2jUg5TzV5gLv","parents":["node_modules/lodash/collection/some.js","node_modules/lodash/internal/equalArrays.js"]},"node_modules/lodash/internal/arrayEach.js":{"index":72,"hash":"eLxUBVsb8vpFbu0VN4KL","parents":["node_modules/lodash/collection/forEach.js"]},"node_modules/lodash/internal/arrayMap.js":{"index":74,"hash":"xdr8c0JsUFapIHTuM5VE","parents":["node_modules/lodash/collection/map.js"]},"node_modules/vueify-insert-css/index.js":{"index":152,"hash":"fvTUijA6yyBpp68H+JX2","parents":["src/components/Select.vue","src/App.vue"]},"node_modules/vue-hot-reload-api/index.js":{"index":150,"hash":"f1FdC0AX0Gv6zyDU4qOs","parents":["src/components/Select.vue","src/components/Jumbotron.vue","src/App.vue"]},"node_modules/ms/index.js":{"index":133,"hash":"HanVKm5AkV6MOdHRAMCT","parents":["node_modules/debug/debug.js"]},"node_modules/debug/debug.js":{"index":47,"hash":"yqdR7nJc7wxIHzFDNzG+","parents":["node_modules/debug/browser.js"]},"node_modules/has-binary/index.js":{"index":61,"hash":"ghM6s7JwI5VY2IMMbY1o","parents":["node_modules/socket.io-client/lib/socket.js"]},"node_modules/socket.io-client/lib/socket.js":{"index":141,"hash":"dZhwrF36uFIGbDZMhss6","parents":["node_modules/socket.io-client/lib/manager.js","node_modules/socket.io-client/lib/index.js"]},"node_modules/socket.io-parser/index.js":{"index":145,"hash":"7PrgORY9faIa3QvXeHjU","parents":["node_modules/socket.io-client/lib/socket.js","node_modules/socket.io-client/lib/manager.js","node_modules/socket.io-client/lib/index.js"]},"node_modules/socket.io-parser/binary.js":{"index":144,"hash":"8I5NRA1rlGtsqsBVMpry","parents":["node_modules/socket.io-parser/index.js"]},"node_modules/lodash/internal/isLength.js":{"index":113,"hash":"DFIKI121VzeE+pBbx1Oa","parents":["node_modules/lodash/internal/createBaseEach.js","node_modules/lodash/internal/isArrayLike.js","node_modules/lodash/lang/isArray.js","node_modules/lodash/object/keysIn.js","node_modules/lodash/internal/shimKeys.js","node_modules/lodash/lang/isTypedArray.js"]},"node_modules/lodash/internal/isObjectLike.js":{"index":114,"hash":"qEGnAWJNoAetOIJ7YKiV","parents":["node_modules/lodash/lang/isNative.js","node_modules/lodash/lang/isArray.js","node_modules/lodash/lang/isArguments.js","node_modules/lodash/lang/isTypedArray.js","node_modules/lodash/internal/baseIsEqual.js"]},"node_modules/lodash/internal/createObjectMapper.js":{"index":102,"hash":"cp8s+Z6khiKdK5QCQ+Ms","parents":["node_modules/lodash/object/mapValues.js"]},"node_modules/lodash/internal/baseCallback.js":{"index":78,"hash":"FDEmxoh1cXY/hddgPNGW","parents":["node_modules/lodash/internal/createObjectMapper.js","node_modules/lodash/collection/map.js","node_modules/lodash/collection/some.js","node_modules/lodash/collection/filter.js"]},"node_modules/lodash/internal/baseForOwn.js":{"index":83,"hash":"sOLmHH2OosmeW92YaLK/","parents":["node_modules/lodash/internal/createObjectMapper.js","node_modules/lodash/internal/baseEach.js","node_modules/lodash/object/forOwn.js"]},"node_modules/lodash/object/mapValues.js":{"index":129,"hash":"2HfAmVuaVGfc8pd5zIaC","parents":["node_modules/browserify-hmr/inc/index.js"]},"node_modules/lodash/utility/identity.js":{"index":131,"hash":"A/cz5O4nnho2x2e5KIWS","parents":["node_modules/lodash/internal/bindCallback.js","node_modules/lodash/internal/baseCallback.js"]},"node_modules/lodash/internal/baseFilter.js":{"index":81,"hash":"yyvQag4hw8sItBFf3/9T","parents":["node_modules/lodash/collection/filter.js"]},"node_modules/lodash/internal/baseEach.js":{"index":80,"hash":"Ji7NLCJhdzSBlpDI+qC3","parents":["node_modules/lodash/internal/baseFilter.js","node_modules/lodash/internal/baseSome.js","node_modules/lodash/internal/baseMap.js","node_modules/lodash/collection/forEach.js"]},"node_modules/lodash/internal/baseSome.js":{"index":94,"hash":"lCW5AtHn9X2vSuPgS8pk","parents":["node_modules/lodash/collection/some.js"]},"node_modules/lodash/internal/isIndex.js":{"index":110,"hash":"I8y5AsjL/lwDlORDOqqM","parents":["node_modules/lodash/internal/isIterateeCall.js","node_modules/lodash/object/keysIn.js","node_modules/lodash/internal/shimKeys.js"]},"node_modules/lodash/lang/isObject.js":{"index":123,"hash":"Go+dTLFqO1KJN+uQLb8s","parents":["node_modules/lodash/internal/toObject.js","node_modules/lodash/internal/isStrictComparable.js","node_modules/lodash/internal/isIterateeCall.js","node_modules/lodash/lang/isFunction.js","node_modules/lodash/object/keysIn.js","node_modules/lodash/object/keys.js","node_modules/lodash/internal/baseIsEqual.js"]},"node_modules/lodash/internal/createForEach.js":{"index":100,"hash":"iJtWBCzx+bzzSLwlaaRv","parents":["node_modules/lodash/collection/forEach.js"]},"node_modules/lodash/lang/isArray.js":{"index":120,"hash":"rpMiE1Z199/XZCjno4KN","parents":["node_modules/lodash/internal/createForEach.js","node_modules/lodash/collection/map.js","node_modules/lodash/internal/isKey.js","node_modules/lodash/internal/toPath.js","node_modules/lodash/collection/some.js","node_modules/lodash/array/zipObject.js","node_modules/lodash/object/keysIn.js","node_modules/lodash/internal/shimKeys.js","node_modules/lodash/internal/baseIsEqualDeep.js","node_modules/lodash/internal/baseMatchesProperty.js","node_modules/lodash/collection/filter.js"]},"node_modules/lodash/internal/bindCallback.js":{"index":96,"hash":"S6iy1I+53IEzDLSGuW0j","parents":["node_modules/lodash/internal/createForEach.js","node_modules/lodash/internal/createForOwn.js","node_modules/lodash/internal/createAssigner.js","node_modules/lodash/internal/baseCallback.js"]},"node_modules/lodash/internal/createForOwn.js":{"index":101,"hash":"KJqijjvJO7d1nU17Sz3c","parents":["node_modules/lodash/object/forOwn.js"]},"node_modules/lodash/function/restParam.js":{"index":71,"hash":"/RRH9MCtjArr1p3Qeh63","parents":["node_modules/lodash/internal/createAssigner.js"]},"node_modules/lodash/internal/createAssigner.js":{"index":97,"hash":"X8R81jvRCofY1BnG+A/L","parents":["node_modules/lodash/object/assign.js"]},"node_modules/lodash/internal/isIterateeCall.js":{"index":111,"hash":"dXMnNRevAizOBisKCEes","parents":["node_modules/lodash/internal/createAssigner.js","node_modules/lodash/collection/some.js"]},"node_modules/lodash/internal/assignWith.js":{"index":76,"hash":"aKBKyfIKqZsNOHAbJTAI","parents":["node_modules/lodash/object/assign.js"]},"node_modules/lodash/object/keys.js":{"index":127,"hash":"BbXGNIcfatSp32uWOBAV","parents":["node_modules/lodash/internal/assignWith.js","node_modules/lodash/internal/baseAssign.js","node_modules/lodash/object/pairs.js","node_modules/lodash/internal/baseForOwn.js","node_modules/lodash/internal/equalObjects.js"]},"node_modules/lodash/internal/baseCopy.js":{"index":79,"hash":"WvGi8IywM6u7ZNXvztwg","parents":["node_modules/lodash/internal/baseAssign.js"]},"node_modules/lodash/internal/baseAssign.js":{"index":77,"hash":"6VX87YoeNgDvMUyiAc/7","parents":["node_modules/lodash/object/assign.js"]},"node_modules/lodash/object/assign.js":{"index":125,"hash":"9WOhJBREl8AO9Hs6Cr+Q","parents":["node_modules/browserify-hmr/inc/index.js"]},"node_modules/lodash/internal/baseMap.js":{"index":88,"hash":"ofv2jCE5QlahpynG4rkN","parents":["node_modules/lodash/collection/map.js"]},"node_modules/lodash/internal/isArrayLike.js":{"index":109,"hash":"76Awthz8ChTgjGk0JZ6Y","parents":["node_modules/lodash/internal/baseMap.js","node_modules/lodash/internal/isIterateeCall.js","node_modules/lodash/lang/isArguments.js","node_modules/lodash/object/keys.js"]},"node_modules/lodash/collection/map.js":{"index":69,"hash":"63n5x8GTiWPuxiZzm9TM","parents":["node_modules/browserify-hmr/inc/index.js"]},"src/countries/simpleCountries.js":{"index":159,"hash":"hLYWkCZR5WGzTBCM7Si4","parents":["src/components/Jumbotron.vue"]},"src/countries/countries.js":{"index":158,"hash":"X8uY48ZCe9q8spDOiZgi","parents":["src/components/Jumbotron.vue"]},"node_modules/lodash/internal/baseProperty.js":{"index":91,"hash":"Yuk2tpof21q0Xl2sQg89","parents":["node_modules/lodash/utility/property.js","node_modules/lodash/internal/getLength.js"]},"node_modules/lodash/internal/baseSlice.js":{"index":93,"hash":"OLgw9XVic1W0AKjehzHB","parents":["node_modules/lodash/internal/baseMatchesProperty.js"]},"node_modules/lodash/array/last.js":{"index":65,"hash":"3oXXa2idWbKySVLcq3os","parents":["node_modules/lodash/internal/baseMatchesProperty.js"]},"node_modules/lodash/internal/createBaseEach.js":{"index":98,"hash":"+5X3Ztm78NNPr9vQZ7fB","parents":["node_modules/lodash/internal/baseEach.js"]},"node_modules/lodash/internal/getLength.js":{"index":106,"hash":"UiZ6F0+nXZ0fiKckTqnM","parents":["node_modules/lodash/internal/createBaseEach.js","node_modules/lodash/internal/isArrayLike.js"]},"node_modules/lodash/internal/toObject.js":{"index":117,"hash":"8f3eulB97DddBRdcU+7v","parents":["node_modules/lodash/internal/createBaseEach.js","node_modules/lodash/internal/isKey.js","node_modules/lodash/internal/baseIsMatch.js","node_modules/lodash/internal/baseGet.js","node_modules/lodash/internal/createBaseFor.js","node_modules/lodash/object/pairs.js","node_modules/lodash/internal/baseMatches.js","node_modules/lodash/internal/baseMatchesProperty.js"]},"node_modules/lodash/collection/forEach.js":{"index":68,"hash":"0Lo1RNt18PMo/HAKbHEu","parents":["node_modules/browserify-hmr/inc/index.js"]},"node_modules/engine.io-parser/lib/keys.js":{"index":59,"hash":"oFyKNTA0twlyQVhVzp9n","parents":["node_modules/engine.io-parser/lib/browser.js"]},"node_modules/arraybuffer.slice/index.js":{"index":3,"hash":"RSb5Zx9CgX3adjzbvf/k","parents":["node_modules/engine.io-parser/lib/browser.js"]},"node_modules/blob/index.js":{"index":8,"hash":"oJwgFCPr7Au6OHJnm0nr","parents":["node_modules/engine.io-parser/lib/browser.js"]},"node_modules/utf8/utf8.js":{"index":149,"hash":"Hbc0UH3rEqjp72mfznNr","parents":["node_modules/engine.io-parser/lib/browser.js"]},"node_modules/after/index.js":{"index":2,"hash":"NzPfXWECmM8rW/6fdkcj","parents":["node_modules/engine.io-parser/lib/browser.js"]},"node_modules/base64-arraybuffer/lib/base64-arraybuffer.js":{"index":7,"hash":"dW6cnktjBIyZ6bv9vRp2","parents":["node_modules/engine.io-parser/lib/browser.js"]},"node_modules/parseqs/index.js":{"index":135,"hash":"FI4tRELwI5Itz+ckwR+m","parents":["node_modules/engine.io-client/lib/transports/websocket.js","node_modules/engine.io-client/lib/transports/polling.js","node_modules/engine.io-client/lib/socket.js"]},"node_modules/parsejson/index.js":{"index":134,"hash":"t92555Kfo3kvbKzdtU/P","parents":["node_modules/engine.io-client/lib/socket.js"]},"node_modules/lodash/internal/isKey.js":{"index":112,"hash":"lDpw5crcRmTRExTLVTKc","parents":["node_modules/lodash/utility/property.js","node_modules/lodash/internal/baseMatchesProperty.js"]},"node_modules/lodash/internal/basePropertyDeep.js":{"index":92,"hash":"mqX1OyYdndJ183lyl/sn","parents":["node_modules/lodash/utility/property.js"]},"node_modules/lodash/internal/baseGet.js":{"index":84,"hash":"H9EiMd3ullQpRkvooLgz","parents":["node_modules/lodash/internal/basePropertyDeep.js","node_modules/lodash/internal/baseMatchesProperty.js"]},"node_modules/lodash/internal/toPath.js":{"index":118,"hash":"faVQvsb+LSLI4uaMgtrQ","parents":["node_modules/lodash/internal/basePropertyDeep.js","node_modules/lodash/internal/baseMatchesProperty.js"]},"node_modules/lodash/utility/property.js":{"index":132,"hash":"7IoOI/uGZCxbcY23uQDK","parents":["node_modules/lodash/internal/baseCallback.js"]},"node_modules/lodash/internal/baseIsMatch.js":{"index":87,"hash":"EpuJzlg204aR35T4QKcS","parents":["node_modules/lodash/internal/baseMatches.js"]},"node_modules/lodash/internal/baseIsEqual.js":{"index":85,"hash":"dBgoFXnhj9KH6oX3dQwa","parents":["node_modules/lodash/internal/baseIsMatch.js","node_modules/lodash/internal/baseMatchesProperty.js"]},"node_modules/lodash/internal/isStrictComparable.js":{"index":115,"hash":"ofNP4/nFrz5Rkb3kGOhn","parents":["node_modules/lodash/internal/getMatchData.js","node_modules/lodash/internal/baseMatchesProperty.js"]},"node_modules/lodash/internal/baseToString.js":{"index":95,"hash":"ABFQFf14pRECi3sw8oKV","parents":["node_modules/lodash/internal/toPath.js"]},"node_modules/lodash/collection/some.js":{"index":70,"hash":"9JyJFfdCx56pmR6fwM9q","parents":["node_modules/browserify-hmr/inc/index.js"]},"node_modules/lodash/internal/createBaseFor.js":{"index":99,"hash":"9RWlFaBOuelvwgkhYgPG","parents":["node_modules/lodash/internal/baseFor.js"]},"node_modules/lodash/internal/baseFor.js":{"index":82,"hash":"NGxcZ0n01+w2G1PzyBlY","parents":["node_modules/lodash/internal/baseForOwn.js"]},"node_modules/engine.io-parser/node_modules/has-binary/index.js":{"index":60,"hash":"aWcciZgvEP4tdxYE2Lfd","parents":["node_modules/engine.io-parser/lib/browser.js"]},"node_modules/engine.io-parser/lib/browser.js":{"index":58,"hash":"X3Q3m2C/zJbJqzepYCjy","parents":["node_modules/engine.io-client/lib/transport.js","node_modules/engine.io-client/lib/transports/websocket.js","node_modules/engine.io-client/lib/transports/polling.js","node_modules/engine.io-client/lib/socket.js","node_modules/engine.io-client/lib/index.js"]},"node_modules/engine.io-client/lib/transport.js":{"index":51,"hash":"qAS1jC8gVTG4yb/AanoB","parents":["node_modules/engine.io-client/lib/transports/websocket.js","node_modules/engine.io-client/lib/transports/polling.js","node_modules/engine.io-client/lib/socket.js"]},"node_modules/browser-resolve/empty.js":{"index":9,"hash":"47DEQpj8HBSa+/TImW+5","parents":["node_modules/engine.io-client/lib/transports/websocket.js"]},"node_modules/lodash/lang/isFunction.js":{"index":121,"hash":"xkfzrZNZPGGOIf0kE8Y9","parents":["node_modules/lodash/lang/isNative.js"]},"node_modules/lodash/lang/isNative.js":{"index":122,"hash":"2rstaALy1DW0JSDdijps","parents":["node_modules/lodash/internal/getNative.js"]},"node_modules/lodash/internal/getNative.js":{"index":108,"hash":"7GRZ7115BSuoc/1bdaBK","parents":["node_modules/lodash/lang/isArray.js","node_modules/lodash/object/keys.js"]},"node_modules/lodash/array/zipObject.js":{"index":66,"hash":"fKfSwIzPo5SUx9d0DkgN","parents":["node_modules/browserify-hmr/inc/index.js"]},"node_modules/lodash/object/pairs.js":{"index":130,"hash":"x6Ilwx8encvg/BW5API2","parents":["node_modules/lodash/internal/getMatchData.js"]},"node_modules/lodash/internal/getMatchData.js":{"index":107,"hash":"n0PHWhNs6YZ+DzgYMHPx","parents":["node_modules/lodash/internal/baseMatches.js"]},"node_modules/lodash/internal/baseMatches.js":{"index":89,"hash":"Cwj5GSiQv9/E8nSFBoX2","parents":["node_modules/lodash/internal/baseCallback.js"]},"node_modules/lodash/internal/equalByTag.js":{"index":104,"hash":"+y++gesJpPvyM+2E8aNB","parents":["node_modules/lodash/internal/baseIsEqualDeep.js"]},"node_modules/lodash/lang/isArguments.js":{"index":119,"hash":"xQ4mqbsKQMCmtsPbfQc6","parents":["node_modules/lodash/object/keysIn.js","node_modules/lodash/internal/shimKeys.js"]},"node_modules/lodash/object/keysIn.js":{"index":128,"hash":"8POZiGR1fRHso579G46Z","parents":["node_modules/lodash/internal/shimKeys.js"]},"node_modules/lodash/internal/shimKeys.js":{"index":116,"hash":"oO4aKopmxRfPxyKgRX9F","parents":["node_modules/lodash/object/keys.js"]},"node_modules/lodash/object/forOwn.js":{"index":126,"hash":"LZ77PzuJW/wlgVPdvlGc","parents":["node_modules/browserify-hmr/inc/index.js"]},"node_modules/has-cors/index.js":{"index":62,"hash":"HwTb4UF/S089ZYA8hrRl","parents":["node_modules/engine.io-client/lib/xmlhttprequest.js"]},"node_modules/engine.io-client/lib/xmlhttprequest.js":{"index":57,"hash":"us0FsN5s7hiT3hqVV5lx","parents":["node_modules/engine.io-client/lib/transports/polling.js","node_modules/engine.io-client/lib/transports/polling-xhr.js","node_modules/engine.io-client/lib/transports/index.js"]},"node_modules/yeast/index.js":{"index":154,"hash":"ZM3+5w4l/D2f6x7svySF","parents":["node_modules/engine.io-client/lib/transports/websocket.js","node_modules/engine.io-client/lib/transports/polling.js"]},"node_modules/component-inherit/index.js":{"index":15,"hash":"T0Fqch4d4akvlr8bh7lc","parents":["node_modules/engine.io-client/lib/transports/websocket.js","node_modules/engine.io-client/lib/transports/polling-jsonp.js","node_modules/engine.io-client/lib/transports/polling.js","node_modules/engine.io-client/lib/transports/polling-xhr.js"]},"node_modules/engine.io-client/lib/transports/websocket.js":{"index":56,"hash":"ZRSUX1iAUU5kMC9oN9hc","parents":["node_modules/engine.io-client/lib/transports/index.js"]},"node_modules/engine.io-client/lib/transports/polling-jsonp.js":{"index":53,"hash":"cw0j0n9JiZAG/Al34gBk","parents":["node_modules/engine.io-client/lib/transports/index.js"]},"node_modules/engine.io-client/lib/transports/polling.js":{"index":55,"hash":"vdgStJPJzZrXTQesqN8z","parents":["node_modules/engine.io-client/lib/transports/polling-jsonp.js","node_modules/engine.io-client/lib/transports/polling-xhr.js"]},"node_modules/lodash/internal/equalArrays.js":{"index":103,"hash":"OBJL6vuaOotu5flUeCnv","parents":["node_modules/lodash/internal/baseIsEqualDeep.js"]},"node_modules/lodash/internal/equalObjects.js":{"index":105,"hash":"44Iy49kDcaAZsykEdaH3","parents":["node_modules/lodash/internal/baseIsEqualDeep.js"]},"node_modules/lodash/lang/isTypedArray.js":{"index":124,"hash":"aVeZyIFGadrEh7EsaDRu","parents":["node_modules/lodash/internal/baseIsEqualDeep.js"]},"node_modules/lodash/internal/baseIsEqualDeep.js":{"index":86,"hash":"ltZZaMHmzp6d9jBltV3Y","parents":["node_modules/lodash/internal/baseIsEqual.js"]},"node_modules/lodash/internal/baseMatchesProperty.js":{"index":90,"hash":"OudnSoeq2A4ql5lg51kc","parents":["node_modules/lodash/internal/baseCallback.js"]},"node_modules/lodash/collection/filter.js":{"index":67,"hash":"XtU5zjCqSDlYcwOLUC13","parents":["node_modules/browserify-hmr/inc/index.js"]},"node_modules/browserify-hmr/inc/index.js":{"index":10,"hash":"azyGnExX2uVlPI7oM92b","parents":[]},"node_modules/core-js/library/modules/$.core.js":{"index":20,"hash":"jO6z5PVz8f6aTUjm5Hrx","parents":["node_modules/core-js/library/modules/$.export.js","node_modules/core-js/library/fn/symbol/index.js"]},"node_modules/core-js/library/modules/es6.object.to-string.js":{"index":44,"hash":"47DEQpj8HBSa+/TImW+5","parents":["node_modules/core-js/library/fn/symbol/index.js"]},"node_modules/engine.io-client/lib/transports/polling-xhr.js":{"index":54,"hash":"idg/D5BOlsKB6+2V6pPe","parents":["node_modules/engine.io-client/lib/transports/index.js"]},"node_modules/engine.io-client/lib/transports/index.js":{"index":52,"hash":"T2DiP0RY+tM6z+OQNF75","parents":["node_modules/engine.io-client/lib/socket.js"]},"node_modules/engine.io-client/lib/socket.js":{"index":50,"hash":"XSGlEwnfJ+YGqRI033+d","parents":["node_modules/engine.io-client/lib/index.js"]},"node_modules/engine.io-client/lib/index.js":{"index":49,"hash":"G6QYuSNu0EcS+G5tR9NE","parents":["node_modules/engine.io-client/index.js"]},"node_modules/engine.io-client/index.js":{"index":48,"hash":"HQau4MkD4lAynB9tt0Wl","parents":["node_modules/socket.io-client/lib/manager.js"]},"node_modules/socket.io-client/lib/manager.js":{"index":139,"hash":"ycazfyz0LQGPtd/P1Ih9","parents":["node_modules/socket.io-client/lib/index.js"]},"node_modules/socket.io-client/lib/index.js":{"index":138,"hash":"6O21Z/SJToLoAyfVkS1+","parents":[]},"node_modules/core-js/library/modules/$.has.js":{"index":29,"hash":"y4idiH2Sj/rmZqd39CHH","parents":["node_modules/core-js/library/modules/$.set-to-string-tag.js","node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.js":{"index":34,"hash":"UI1ymRgurU07soRpiobz","parents":["node_modules/core-js/library/modules/$.set-to-string-tag.js","node_modules/core-js/library/modules/$.keyof.js","node_modules/core-js/library/modules/$.enum-keys.js","node_modules/core-js/library/modules/$.get-names.js","node_modules/core-js/library/modules/$.hide.js","node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.fails.js":{"index":26,"hash":"6G4+YXaRghTGQQnkm/qp","parents":["node_modules/core-js/library/modules/$.descriptors.js","node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.global.js":{"index":28,"hash":"t7QKkyeVEU+gGSy/l5Cc","parents":["node_modules/core-js/library/modules/$.shared.js","node_modules/core-js/library/modules/$.wks.js","node_modules/core-js/library/modules/$.export.js","node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.uid.js":{"index":42,"hash":"auy0a5KBxuU7QAdJ7we/","parents":["node_modules/core-js/library/modules/$.wks.js","node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.property-desc.js":{"index":37,"hash":"iSs9jpAw1JT2ZWWLScSH","parents":["node_modules/core-js/library/modules/$.hide.js","node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.library.js":{"index":36,"hash":"Bhgn5RpO7pDcQnSVaI5C","parents":["node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.descriptors.js":{"index":23,"hash":"NJqnAOVs55bKea+gKIGt","parents":["node_modules/core-js/library/modules/$.hide.js","node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.shared.js":{"index":40,"hash":"ZK+Tn2LANbB4OqkscM3N","parents":["node_modules/core-js/library/modules/$.wks.js","node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.set-to-string-tag.js":{"index":39,"hash":"3G0pjz42ePfLP++caEH3","parents":["node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.wks.js":{"index":43,"hash":"qMliszffX6kySHptJTIp","parents":["node_modules/core-js/library/modules/$.set-to-string-tag.js","node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.keyof.js":{"index":35,"hash":"QAkD89X3k/nEd4vAmyCz","parents":["node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.to-iobject.js":{"index":41,"hash":"yp4UOuCLRVO1tqlgppw5","parents":["node_modules/core-js/library/modules/$.keyof.js","node_modules/core-js/library/modules/$.get-names.js","node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.enum-keys.js":{"index":24,"hash":"d/Ib2kcvofwv5M39O14Y","parents":["node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.get-names.js":{"index":27,"hash":"YHazxvllS2UBE+8VU/uH","parents":["node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.is-object.js":{"index":33,"hash":"FkaOOMIm0uw4T/qUEXed","parents":["node_modules/core-js/library/modules/$.an-object.js"]},"node_modules/core-js/library/modules/$.an-object.js":{"index":18,"hash":"d7pCynXJhKpK2u1S0fph","parents":["node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.cof.js":{"index":19,"hash":"FY6tg0ymdCS/rEwpAa7R","parents":["node_modules/core-js/library/modules/$.is-array.js","node_modules/core-js/library/modules/$.iobject.js"]},"node_modules/core-js/library/modules/$.is-array.js":{"index":32,"hash":"xN9Fwd6YjBUWmVzBxcVm","parents":["node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.defined.js":{"index":22,"hash":"RZr8uFl+WrrjvGzPSz3c","parents":["node_modules/core-js/library/modules/$.to-iobject.js"]},"node_modules/core-js/library/modules/$.iobject.js":{"index":31,"hash":"HvETp5p0zMBjh+wvjxSm","parents":["node_modules/core-js/library/modules/$.to-iobject.js"]},"node_modules/core-js/library/modules/$.hide.js":{"index":30,"hash":"2HBwvxEtbt4UpskOWy62","parents":["node_modules/core-js/library/modules/$.redefine.js"]},"node_modules/core-js/library/modules/$.redefine.js":{"index":38,"hash":"v4z59Kie6WPVO1h+8oJP","parents":["node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/$.a-function.js":{"index":17,"hash":"vI7NBVNoKizw/T7ablYt","parents":["node_modules/core-js/library/modules/$.ctx.js"]},"node_modules/core-js/library/modules/$.ctx.js":{"index":21,"hash":"IBAqoysxf6uGe4qIslFW","parents":["node_modules/core-js/library/modules/$.export.js"]},"node_modules/core-js/library/modules/$.export.js":{"index":25,"hash":"tF6TuwqA3fLdeFKqSI9n","parents":["node_modules/core-js/library/modules/es6.symbol.js"]},"node_modules/core-js/library/modules/es6.symbol.js":{"index":45,"hash":"RB3U/3ZSwfWuCvaaW2A4","parents":["node_modules/core-js/library/fn/symbol/index.js"]},"node_modules/core-js/library/fn/symbol/index.js":{"index":16,"hash":"2EnyuJY8T+YSjL7XPyTs","parents":["node_modules/babel-runtime/core-js/symbol.js"]},"node_modules/babel-runtime/core-js/symbol.js":{"index":4,"hash":"aiWeZ2ndRLi+VSl8A+j6","parents":["node_modules/babel-runtime/helpers/typeof.js"]},"node_modules/babel-runtime/helpers/typeof.js":{"index":5,"hash":"EmXNwlygan5mvsdVpEzI","parents":["src/components/Select.vue"]},"src/components/Select.vue":{"index":157,"hash":"wlg8anPzo8gxDM6p0Cs7","parents":["src/components/Jumbotron.vue"]},"src/components/Jumbotron.vue":{"index":156,"hash":"XTffrFkQCRxXIb0VJWLn","parents":["src/App.vue"]},"src/App.vue":{"index":155,"hash":"CamSgByskedxduMbol7z","parents":["src/main.js"]},"node_modules/vuex/dist/vuex.js":{"index":153,"hash":"gX//W6yHs/IFY/kkM/lI","parents":["src/vuex/store.js"]},"src/vuex/store.js":{"index":161,"hash":"hwHd4AxvLYr1C+NBOgh/","parents":["src/main.js"]},"src/main.js":{"index":160,"hash":"z2sdYiItshBNRWvsUwFd","parents":[]}};
|
||
var originalEntries = ["/Volumes/Documents/Dropbox/htdocs/vue-select/src/main.js"];
|
||
var updateUrl = null;
|
||
var updateMode = "websocket";
|
||
var supportModes = ["none","websocket"];
|
||
var ignoreUnaccepted = true;
|
||
var updateCacheBust = false;
|
||
var bundleKey = "websocket:null";
|
||
var sioPath = "./node_modules/socket.io-client/lib/index.js";
|
||
var incPath = "./node_modules/browserify-hmr/inc/index.js";
|
||
|
||
if (!global._hmr) {
|
||
try {
|
||
Object.defineProperty(global, '_hmr', {value: {}});
|
||
} catch(e) {
|
||
global._hmr = {};
|
||
}
|
||
}
|
||
|
||
if (!Object.prototype.hasOwnProperty.call(global._hmr, bundleKey)) {
|
||
// Temporary hack so requiring modules works before the _hmr values are
|
||
// correctly initialized.
|
||
global._hmr[bundleKey] = {initModule: function(){}};
|
||
}
|
||
|
||
var main = require(incPath);
|
||
var isFirstRun = main(
|
||
moduleDefs, cachedModules, moduleMeta, updateUrl,
|
||
updateMode, supportModes, ignoreUnaccepted, updateCacheBust, bundleKey,
|
||
sioPath ? require(sioPath) : null,
|
||
typeof __filename !== 'undefined' && __filename,
|
||
typeof __dirname !== 'undefined' && __dirname
|
||
);
|
||
if (isFirstRun) {
|
||
for (var i=0, len=originalEntries.length; i<len; i++) {
|
||
require(originalEntries[i]);
|
||
}
|
||
}
|
||
}).call(
|
||
this,
|
||
typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},
|
||
arguments[3], arguments[4], arguments[5], arguments[6]
|
||
);
|
||
|
||
},{"./node_modules/browserify-hmr/inc/index.js":10,"./node_modules/socket.io-client/lib/index.js":138,"/Volumes/Documents/Dropbox/htdocs/vue-select/src/main.js":160}]},{},[1])
|
||
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/after/index.js","node_modules/arraybuffer.slice/index.js","node_modules/babel-runtime/core-js/symbol.js","node_modules/babel-runtime/helpers/typeof.js","node_modules/backo2/index.js","node_modules/base64-arraybuffer/lib/base64-arraybuffer.js","node_modules/blob/index.js","node_modules/browser-resolve/empty.js","node_modules/browserify-hmr/inc/index.js","node_modules/browserify-hmr/lib/has.js","node_modules/browserify-hmr/lib/str-set.js","node_modules/component-bind/index.js","node_modules/component-emitter/index.js","node_modules/component-inherit/index.js","node_modules/core-js/library/fn/symbol/index.js","node_modules/core-js/library/modules/$.a-function.js","node_modules/core-js/library/modules/$.an-object.js","node_modules/core-js/library/modules/$.cof.js","node_modules/core-js/library/modules/$.core.js","node_modules/core-js/library/modules/$.ctx.js","node_modules/core-js/library/modules/$.defined.js","node_modules/core-js/library/modules/$.descriptors.js","node_modules/core-js/library/modules/$.enum-keys.js","node_modules/core-js/library/modules/$.export.js","node_modules/core-js/library/modules/$.fails.js","node_modules/core-js/library/modules/$.get-names.js","node_modules/core-js/library/modules/$.global.js","node_modules/core-js/library/modules/$.has.js","node_modules/core-js/library/modules/$.hide.js","node_modules/core-js/library/modules/$.iobject.js","node_modules/core-js/library/modules/$.is-array.js","node_modules/core-js/library/modules/$.is-object.js","node_modules/core-js/library/modules/$.js","node_modules/core-js/library/modules/$.keyof.js","node_modules/core-js/library/modules/$.library.js","node_modules/core-js/library/modules/$.property-desc.js","node_modules/core-js/library/modules/$.redefine.js","node_modules/core-js/library/modules/$.set-to-string-tag.js","node_modules/core-js/library/modules/$.shared.js","node_modules/core-js/library/modules/$.to-iobject.js","node_modules/core-js/library/modules/$.uid.js","node_modules/core-js/library/modules/$.wks.js","node_modules/core-js/library/modules/es6.object.to-string.js","node_modules/core-js/library/modules/es6.symbol.js","node_modules/debug/browser.js","node_modules/debug/debug.js","node_modules/engine.io-client/index.js","node_modules/engine.io-client/lib/index.js","node_modules/engine.io-client/lib/socket.js","node_modules/engine.io-client/lib/transport.js","node_modules/engine.io-client/lib/transports/index.js","node_modules/engine.io-client/lib/transports/polling-jsonp.js","node_modules/engine.io-client/lib/transports/polling-xhr.js","node_modules/engine.io-client/lib/transports/polling.js","node_modules/engine.io-client/lib/transports/websocket.js","node_modules/engine.io-client/lib/xmlhttprequest.js","node_modules/engine.io-parser/lib/browser.js","node_modules/engine.io-parser/lib/keys.js","node_modules/engine.io-parser/node_modules/has-binary/index.js","node_modules/has-binary/index.js","node_modules/has-cors/index.js","node_modules/indexof/index.js","node_modules/isarray/index.js","node_modules/lodash/array/last.js","node_modules/lodash/array/zipObject.js","node_modules/lodash/collection/filter.js","node_modules/lodash/collection/forEach.js","node_modules/lodash/collection/map.js","node_modules/lodash/collection/some.js","node_modules/lodash/function/restParam.js","node_modules/lodash/internal/arrayEach.js","node_modules/lodash/internal/arrayFilter.js","node_modules/lodash/internal/arrayMap.js","node_modules/lodash/internal/arraySome.js","node_modules/lodash/internal/assignWith.js","node_modules/lodash/internal/baseAssign.js","node_modules/lodash/internal/baseCallback.js","node_modules/lodash/internal/baseCopy.js","node_modules/lodash/internal/baseEach.js","node_modules/lodash/internal/baseFilter.js","node_modules/lodash/internal/baseFor.js","node_modules/lodash/internal/baseForOwn.js","node_modules/lodash/internal/baseGet.js","node_modules/lodash/internal/baseIsEqual.js","node_modules/lodash/internal/baseIsEqualDeep.js","node_modules/lodash/internal/baseIsMatch.js","node_modules/lodash/internal/baseMap.js","node_modules/lodash/internal/baseMatches.js","node_modules/lodash/internal/baseMatchesProperty.js","node_modules/lodash/internal/baseProperty.js","node_modules/lodash/internal/basePropertyDeep.js","node_modules/lodash/internal/baseSlice.js","node_modules/lodash/internal/baseSome.js","node_modules/lodash/internal/baseToString.js","node_modules/lodash/internal/bindCallback.js","node_modules/lodash/internal/createAssigner.js","node_modules/lodash/internal/createBaseEach.js","node_modules/lodash/internal/createBaseFor.js","node_modules/lodash/internal/createForEach.js","node_modules/lodash/internal/createForOwn.js","node_modules/lodash/internal/createObjectMapper.js","node_modules/lodash/internal/equalArrays.js","node_modules/lodash/internal/equalByTag.js","node_modules/lodash/internal/equalObjects.js","node_modules/lodash/internal/getLength.js","node_modules/lodash/internal/getMatchData.js","node_modules/lodash/internal/getNative.js","node_modules/lodash/internal/isArrayLike.js","node_modules/lodash/internal/isIndex.js","node_modules/lodash/internal/isIterateeCall.js","node_modules/lodash/internal/isKey.js","node_modules/lodash/internal/isLength.js","node_modules/lodash/internal/isObjectLike.js","node_modules/lodash/internal/isStrictComparable.js","node_modules/lodash/internal/shimKeys.js","node_modules/lodash/internal/toObject.js","node_modules/lodash/internal/toPath.js","node_modules/lodash/lang/isArguments.js","node_modules/lodash/lang/isArray.js","node_modules/lodash/lang/isFunction.js","node_modules/lodash/lang/isNative.js","node_modules/lodash/lang/isObject.js","node_modules/lodash/lang/isTypedArray.js","node_modules/lodash/object/assign.js","node_modules/lodash/object/forOwn.js","node_modules/lodash/object/keys.js","node_modules/lodash/object/keysIn.js","node_modules/lodash/object/mapValues.js","node_modules/lodash/object/pairs.js","node_modules/lodash/utility/identity.js","node_modules/lodash/utility/property.js","node_modules/ms/index.js","node_modules/parsejson/index.js","node_modules/parseqs/index.js","node_modules/parseuri/index.js","node_modules/process/browser.js","node_modules/socket.io-client/lib/index.js","node_modules/socket.io-client/lib/manager.js","node_modules/socket.io-client/lib/on.js","node_modules/socket.io-client/lib/socket.js","node_modules/socket.io-client/lib/url.js","node_modules/socket.io-client/node_modules/component-emitter/index.js","node_modules/socket.io-parser/binary.js","node_modules/socket.io-parser/index.js","node_modules/socket.io-parser/is-buffer.js","node_modules/socket.io-parser/node_modules/json3/lib/json3.js","node_modules/to-array/index.js","node_modules/utf8/utf8.js","node_modules/vue-hot-reload-api/index.js","node_modules/vue/dist/vue.common.js","node_modules/vueify-insert-css/index.js","node_modules/vuex/dist/vuex.js","node_modules/yeast/index.js","src/App.vue","src/components/Jumbotron.vue","src/components/Select.vue","src/countries/countries.js","src/countries/simpleCountries.js","src/main.js","src/vuex/store.js","__hmr_manager.js"],"names":[],"mappings":"AAAA;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC5BA,uF;;;;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0B;;;;;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AC1DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;ACh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lpBA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC1EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACnKA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACNA;AACA;AACA,wD;;;;;;ACFA;AACA;AACA;AACA,E;;;;;;ACHA;AACA;AACA;AACA;AACA,E;;;;;;ACJA;AACA;AACA;AACA;AACA,E;;;;;;ACJA;AACA,qE;;;;;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACnBA;AACA;AACA;AACA;AACA,E;;;;;;ACJA;AACA;AACA;AACA,G;;;;;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yB;;;;;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACnBA;AACA;AACA;AACA,uE;;;;;;ACHA;AACA;AACA;AACA,E;;;;;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACPA;AACA;AACA;AACA;AACA,E;;;;;;ACJA;AACA;AACA;AACA;AACA,E;;;;;;ACJA;AACA;AACA,E;;;;;;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACTA,sB;;;;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACPA,qC;;;;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACNA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACLA;AACA;AACA;AACA;AACA,E;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;ACNA;AACA;AACA;AACA;AACA;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0C;;;;;;AClOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACvKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACp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xtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AC1JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;AC9OA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AC5ZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACtPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AChSA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACllBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;AC1DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AC3DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACTA;AACA;AACA;;;;;;;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC5DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AClEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACzDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACrGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AClDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AClEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACzEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC/DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AC5HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACt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iBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AC3ZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AC5EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AChKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AC7IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AC/YA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACt4BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACpPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACzSA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AC19SA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,I;;;;;;AC/jBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,K;;;;;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,K;;;;;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,K;;;;;;;;ACjNA,OAAO,OAAP,GAAiB,CACH,EAAC,OAAO,IAAP,EAAa,OAAO,aAAP,EADX,EAEH,EAAC,OAAO,IAAP,EAAa,OAAO,eAAP,EAFX,EAGH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAHX,EAIH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAJX,EAKH,EAAC,OAAO,IAAP,EAAa,OAAO,gBAAP,EALX,EAMH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EANX,EAOH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAPX,EAQH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EARX,EASH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EATX,EAUH,EAAC,OAAO,IAAP,EAAa,OAAO,qBAAP,EAVX,EAWH,EAAC,OAAO,IAAP,EAAa,OAAO,WAAP,EAXX,EAYH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAZX,EAaH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EAbX,EAcH,EAAC,OAAO,IAAP,EAAa,OAAO,WAAP,EAdX,EAeH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAfX,EAgBH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EAhBX,EAiBH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAjBX,EAkBH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAlBX,EAmBH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EAnBX,EAoBH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EApBX,EAqBH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EArBX,EAsBH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAtBX,EAuBH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAvBX,EAwBH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EAxBX,EAyBH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAzBX,EA0BH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EA1BX,EA2BH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EA3BX,EA4BH,EAAC,OAAO,IAAP,EAAa,OAAO,wBAAP,EA5BX,EA6BH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EA7BX,EA8BH,EAAC,OAAO,IAAP,EAAa,OAAO,eAAP,EA9BX,EA+BH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EA/BX,EAgCH,EAAC,OAAO,IAAP,EAAa,OAAO,gCAAP,EAhCX,EAiCH,EAAC,OAAO,IAAP,EAAa,OAAO,mBAAP,EAjCX,EAkCH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EAlCX,EAmCH,EAAC,OAAO,IAAP,EAAa,OAAO,cAAP,EAnCX,EAoCH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EApCX,EAqCH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EArCX,EAsCH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EAtCX,EAuCH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAvCX,EAwCH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EAxCX,EAyCH,EAAC,OAAO,IAAP,EAAa,OAAO,gBAAP,EAzCX,EA0CH,EAAC,OAAO,IAAP,EAAa,OAAO,0BAAP,EA1CX,EA2CH,EAAC,OAAO,IAAP,EAAa,OAAO,MAAP,EA3CX,EA4CH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EA5CX,EA6CH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EA7CX,EA8CH,EAAC,OAAO,IAAP,EAAa,OAAO,kBAAP,EA9CX,EA+CH,EAAC,OAAO,IAAP,EAAa,OAAO,yBAAP,EA/CX,EAgDH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EAhDX,EAiDH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAjDX,EAkDH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EAlDX,EAmDH,EAAC,OAAO,IAAP,EAAa,OAAO,uCAAP,EAnDX,EAoDH,EAAC,OAAO,IAAP,EAAa,OAAO,cAAP,EApDX,EAqDH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EArDX,EAsDH,EAAC,OAAO,IAAP,EAAa,OAAO,eAAP,EAtDX,EAuDH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAvDX,EAwDH,EAAC,OAAO,IAAP,EAAa,OAAO,MAAP,EAxDX,EAyDH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAzDX,EA0DH,EAAC,OAAO,IAAP,EAAa,OAAO,gBAAP,EA1DX,EA2DH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EA3DX,EA4DH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EA5DX,EA6DH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EA7DX,EA8DH,EAAC,OAAO,IAAP,EAAa,OAAO,oBAAP,EA9DX,EA+DH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EA/DX,EAgEH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EAhEX,EAiEH,EAAC,OAAO,IAAP,EAAa,OAAO,aAAP,EAjEX,EAkEH,EAAC,OAAO,IAAP,EAAa,OAAO,mBAAP,EAlEX,EAmEH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAnEX,EAoEH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EApEX,EAqEH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EArEX,EAsEH,EAAC,OAAO,IAAP,EAAa,OAAO,6BAAP,EAtEX,EAuEH,EAAC,OAAO,IAAP,EAAa,OAAO,eAAP,EAvEX,EAwEH,EAAC,OAAO,IAAP,EAAa,OAAO,MAAP,EAxEX,EAyEH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAzEX,EA0EH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EA1EX,EA2EH,EAAC,OAAO,IAAP,EAAa,OAAO,eAAP,EA3EX,EA4EH,EAAC,OAAO,IAAP,EAAa,OAAO,kBAAP,EA5EX,EA6EH,EAAC,OAAO,IAAP,EAAa,OAAO,6BAAP,EA7EX,EA8EH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EA9EX,EA+EH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EA/EX,EAgFH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAhFX,EAiFH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAjFX,EAkFH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EAlFX,EAmFH,EAAC,OAAO,IAAP,EAAa,OAAO,WAAP,EAnFX,EAoFH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EApFX,EAqFH,EAAC,OAAO,IAAP,EAAa,OAAO,WAAP,EArFX,EAsFH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAtFX,EAuFH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EAvFX,EAwFH,EAAC,OAAO,IAAP,EAAa,OAAO,MAAP,EAxFX,EAyFH,EAAC,OAAO,IAAP,EAAa,OAAO,WAAP,EAzFX,EA0FH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EA1FX,EA2FH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EA3FX,EA4FH,EAAC,OAAO,IAAP,EAAa,OAAO,eAAP,EA5FX,EA6FH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EA7FX,EA8FH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EA9FX,EA+FH,EAAC,OAAO,IAAP,EAAa,OAAO,mCAAP,EA/FX,EAgGH,EAAC,OAAO,IAAP,EAAa,OAAO,+BAAP,EAhGX,EAiGH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EAjGX,EAkGH,EAAC,OAAO,IAAP,EAAa,OAAO,WAAP,EAlGX,EAmGH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAnGX,EAoGH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EApGX,EAqGH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EArGX,EAsGH,EAAC,OAAO,IAAP,EAAa,OAAO,WAAP,EAtGX,EAuGH,EAAC,OAAO,IAAP,EAAa,OAAO,2BAAP,EAvGX,EAwGH,EAAC,OAAO,IAAP,EAAa,OAAO,MAAP,EAxGX,EAyGH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAzGX,EA0GH,EAAC,OAAO,IAAP,EAAa,OAAO,aAAP,EA1GX,EA2GH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EA3GX,EA4GH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EA5GX,EA6GH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EA7GX,EA8GH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EA9GX,EA+GH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EA/GX,EAgHH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAhHX,EAiHH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EAjHX,EAkHH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EAlHX,EAmHH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EAnHX,EAoHH,EAAC,OAAO,IAAP,EAAa,OAAO,wCAAP,EApHX,EAqHH,EAAC,OAAO,IAAP,EAAa,OAAO,oBAAP,EArHX,EAsHH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAtHX,EAuHH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EAvHX,EAwHH,EAAC,OAAO,IAAP,EAAa,OAAO,kCAAP,EAxHX,EAyHH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAzHX,EA0HH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EA1HX,EA2HH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EA3HX,EA4HH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EA5HX,EA6HH,EAAC,OAAO,IAAP,EAAa,OAAO,wBAAP,EA7HX,EA8HH,EAAC,OAAO,IAAP,EAAa,OAAO,eAAP,EA9HX,EA+HH,EAAC,OAAO,IAAP,EAAa,OAAO,WAAP,EA/HX,EAgIH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EAhIX,EAiIH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EAjIX,EAkIH,EAAC,OAAO,IAAP,EAAa,OAAO,4CAAP,EAlIX,EAmIH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EAnIX,EAoIH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EApIX,EAqIH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EArIX,EAsIH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EAtIX,EAuIH,EAAC,OAAO,IAAP,EAAa,OAAO,MAAP,EAvIX,EAwIH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EAxIX,EAyIH,EAAC,OAAO,IAAP,EAAa,OAAO,kBAAP,EAzIX,EA0IH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EA1IX,EA2IH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EA3IX,EA4IH,EAAC,OAAO,IAAP,EAAa,OAAO,WAAP,EA5IX,EA6IH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EA7IX,EA8IH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EA9IX,EA+IH,EAAC,OAAO,IAAP,EAAa,OAAO,iCAAP,EA/IX,EAgJH,EAAC,OAAO,IAAP,EAAa,OAAO,sBAAP,EAhJX,EAiJH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAjJX,EAkJH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EAlJX,EAmJH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EAnJX,EAoJH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EApJX,EAqJH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EArJX,EAsJH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EAtJX,EAuJH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAvJX,EAwJH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAxJX,EAyJH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EAzJX,EA0JH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EA1JX,EA2JH,EAAC,OAAO,IAAP,EAAa,OAAO,aAAP,EA3JX,EA4JH,EAAC,OAAO,IAAP,EAAa,OAAO,sBAAP,EA5JX,EA6JH,EAAC,OAAO,IAAP,EAAa,OAAO,eAAP,EA7JX,EA8JH,EAAC,OAAO,IAAP,EAAa,OAAO,aAAP,EA9JX,EA+JH,EAAC,OAAO,IAAP,EAAa,OAAO,WAAP,EA/JX,EAgKH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EAhKX,EAiKH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAjKX,EAkKH,EAAC,OAAO,IAAP,EAAa,OAAO,MAAP,EAlKX,EAmKH,EAAC,OAAO,IAAP,EAAa,OAAO,gBAAP,EAnKX,EAoKH,EAAC,OAAO,IAAP,EAAa,OAAO,0BAAP,EApKX,EAqKH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EArKX,EAsKH,EAAC,OAAO,IAAP,EAAa,OAAO,MAAP,EAtKX,EAuKH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EAvKX,EAwKH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EAxKX,EAyKH,EAAC,OAAO,IAAP,EAAa,OAAO,iCAAP,EAzKX,EA0KH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EA1KX,EA2KH,EAAC,OAAO,IAAP,EAAa,OAAO,kBAAP,EA3KX,EA4KH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EA5KX,EA6KH,EAAC,OAAO,IAAP,EAAa,OAAO,MAAP,EA7KX,EA8KH,EAAC,OAAO,IAAP,EAAa,OAAO,aAAP,EA9KX,EA+KH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EA/KX,EAgLH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAhLX,EAiLH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EAjLX,EAkLH,EAAC,OAAO,IAAP,EAAa,OAAO,aAAP,EAlLX,EAmLH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EAnLX,EAoLH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EApLX,EAqLH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EArLX,EAsLH,EAAC,OAAO,IAAP,EAAa,OAAO,oBAAP,EAtLX,EAuLH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAvLX,EAwLH,EAAC,OAAO,IAAP,EAAa,OAAO,cAAP,EAxLX,EAyLH,EAAC,OAAO,IAAP,EAAa,OAAO,uBAAP,EAzLX,EA0LH,EAAC,OAAO,IAAP,EAAa,OAAO,aAAP,EA1LX,EA2LH,EAAC,OAAO,IAAP,EAAa,OAAO,2BAAP,EA3LX,EA4LH,EAAC,OAAO,IAAP,EAAa,OAAO,kCAAP,EA5LX,EA6LH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EA7LX,EA8LH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EA9LX,EA+LH,EAAC,OAAO,IAAP,EAAa,OAAO,uBAAP,EA/LX,EAgMH,EAAC,OAAO,IAAP,EAAa,OAAO,cAAP,EAhMX,EAiMH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAjMX,EAkMH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAlMX,EAmMH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EAnMX,EAoMH,EAAC,OAAO,IAAP,EAAa,OAAO,cAAP,EApMX,EAqMH,EAAC,OAAO,IAAP,EAAa,OAAO,WAAP,EArMX,EAsMH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EAtMX,EAuMH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EAvMX,EAwMH,EAAC,OAAO,IAAP,EAAa,OAAO,iBAAP,EAxMX,EAyMH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAzMX,EA0MH,EAAC,OAAO,IAAP,EAAa,OAAO,cAAP,EA1MX,EA2MH,EAAC,OAAO,IAAP,EAAa,OAAO,8CAAP,EA3MX,EA4MH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EA5MX,EA6MH,EAAC,OAAO,IAAP,EAAa,OAAO,WAAP,EA7MX,EA8MH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EA9MX,EA+MH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EA/MX,EAgNH,EAAC,OAAO,IAAP,EAAa,OAAO,wBAAP,EAhNX,EAiNH,EAAC,OAAO,IAAP,EAAa,OAAO,WAAP,EAjNX,EAkNH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAlNX,EAmNH,EAAC,OAAO,IAAP,EAAa,OAAO,aAAP,EAnNX,EAoNH,EAAC,OAAO,IAAP,EAAa,OAAO,sBAAP,EApNX,EAqNH,EAAC,OAAO,IAAP,EAAa,OAAO,2BAAP,EArNX,EAsNH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EAtNX,EAuNH,EAAC,OAAO,IAAP,EAAa,OAAO,8BAAP,EAvNX,EAwNH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EAxNX,EAyNH,EAAC,OAAO,IAAP,EAAa,OAAO,aAAP,EAzNX,EA0NH,EAAC,OAAO,IAAP,EAAa,OAAO,MAAP,EA1NX,EA2NH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EA3NX,EA4NH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EA5NX,EA6NH,EAAC,OAAO,IAAP,EAAa,OAAO,qBAAP,EA7NX,EA8NH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EA9NX,EA+NH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EA/NX,EAgOH,EAAC,OAAO,IAAP,EAAa,OAAO,cAAP,EAhOX,EAiOH,EAAC,OAAO,IAAP,EAAa,OAAO,0BAAP,EAjOX,EAkOH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAlOX,EAmOH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAnOX,EAoOH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EApOX,EAqOH,EAAC,OAAO,IAAP,EAAa,OAAO,sBAAP,EArOX,EAsOH,EAAC,OAAO,IAAP,EAAa,OAAO,gBAAP,EAtOX,EAuOH,EAAC,OAAO,IAAP,EAAa,OAAO,eAAP,EAvOX,EAwOH,EAAC,OAAO,IAAP,EAAa,OAAO,sCAAP,EAxOX,EAyOH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EAzOX,EA0OH,EAAC,OAAO,IAAP,EAAa,OAAO,YAAP,EA1OX,EA2OH,EAAC,OAAO,IAAP,EAAa,OAAO,SAAP,EA3OX,EA4OH,EAAC,OAAO,IAAP,EAAa,OAAO,WAAP,EA5OX,EA6OH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EA7OX,EA8OH,EAAC,OAAO,IAAP,EAAa,OAAO,yBAAP,EA9OX,EA+OH,EAAC,OAAO,IAAP,EAAa,OAAO,sBAAP,EA/OX,EAgPH,EAAC,OAAO,IAAP,EAAa,OAAO,mBAAP,EAhPX,EAiPH,EAAC,OAAO,IAAP,EAAa,OAAO,gBAAP,EAjPX,EAkPH,EAAC,OAAO,IAAP,EAAa,OAAO,OAAP,EAlPX,EAmPH,EAAC,OAAO,IAAP,EAAa,OAAO,QAAP,EAnPX,EAoPH,EAAC,OAAO,IAAP,EAAa,OAAO,UAAP,EApPX,CAAjB;;;;;;;;;ACAA,OAAO,OAAP,GAAiB,CAAC,aAAD,EAAe,eAAf,EAA+B,SAA/B,EAAyC,SAAzC,EAAmD,gBAAnD,EAAoE,SAApE,EAA8E,QAA9E,EAAuF,UAAvF,EAAkG,YAAlG,EAA+G,qBAA/G,EAAqI,WAArI,EAAiJ,SAAjJ,EAA2J,OAA3J,EAAmK,WAAnK,EAA+K,SAA/K,EAAyL,YAAzL,EAAsM,SAAtM,EAAgN,SAAhN,EAA0N,YAA1N,EAAuO,UAAvO,EAAkP,SAAlP,EAA4P,SAA5P,EAAsQ,QAAtQ,EAA+Q,OAA/Q,EAAuR,SAAvR,EAAiS,QAAjS,EAA0S,SAA1S,EAAoT,wBAApT,EAA6U,UAA7U,EAAwV,eAAxV,EAAwW,QAAxW,EAAiX,gCAAjX,EAAkZ,mBAAlZ,EAAsa,UAAta,EAAib,cAAjb,EAAgc,SAAhc,EAA0c,UAA1c,EAAqd,UAArd,EAAge,QAAhe,EAAye,YAAze,EAAsf,gBAAtf,EAAugB,0BAAvgB,EAAkiB,MAAliB,EAAyiB,OAAziB,EAAijB,OAAjjB,EAAyjB,kBAAzjB,EAA4kB,yBAA5kB,EAAsmB,UAAtmB,EAAinB,SAAjnB,EAA2nB,OAA3nB,EAAmoB,uCAAnoB,EAA2qB,cAA3qB,EAA0rB,YAA1rB,EAAusB,eAAvsB,EAAutB,SAAvtB,EAAiuB,MAAjuB,EAAwuB,QAAxuB,EAAivB,gBAAjvB,EAAkwB,SAAlwB,EAA4wB,UAA5wB,EAAuxB,UAAvxB,EAAkyB,oBAAlyB,EAAuzB,SAAvzB,EAAi0B,OAAj0B,EAAy0B,aAAz0B,EAAu1B,mBAAv1B,EAA22B,SAA32B,EAAq3B,SAAr3B,EAA+3B,UAA/3B,EAA04B,6BAA14B,EAAw6B,eAAx6B,EAAw7B,MAAx7B,EAA+7B,SAA/7B,EAAy8B,QAAz8B,EAAk9B,eAAl9B,EAAk+B,kBAAl+B,EAAq/B,6BAAr/B,EAAmhC,OAAnhC,EAA2hC,QAA3hC,EAAoiC,SAApiC,EAA8iC,SAA9iC,EAAwjC,OAAxjC,EAAgkC,WAAhkC,EAA4kC,QAA5kC,EAAqlC,WAArlC,EAAimC,SAAjmC,EAA2mC,YAA3mC,EAAwnC,MAAxnC,EAA+nC,WAA/nC,EAA2oC,UAA3oC,EAAspC,QAAtpC,EAA+pC,eAA/pC,EAA+qC,QAA/qC,EAAwrC,OAAxrC,EAAgsC,mCAAhsC,EAAouC,+BAApuC,EAAowC,UAApwC,EAA+wC,WAA/wC,EAA2xC,SAA3xC,EAAqyC,SAAryC,EAA+yC,OAA/yC,EAAuzC,WAAvzC,EAAm0C,2BAAn0C,EAA+1C,MAA/1C,EAAs2C,SAAt2C,EAAg3C,aAAh3C,EAA83C,QAA93C,EAAu4C,OAAv4C,EAA+4C,SAA/4C,EAAy5C,OAAz5C,EAAi6C,QAAj6C,EAA06C,QAA16C,EAAm7C,YAAn7C,EAAg8C,OAAh8C,EAAw8C,UAAx8C,EAAm9C,wCAAn9C,EAA4/C,oBAA5/C,EAAihD,QAAjhD,EAA0hD,YAA1hD,EAAuiD,kCAAviD,EAA0kD,QAA1kD,EAAmlD,SAAnlD,EAA6lD,SAA7lD,EAAumD,SAAvmD,EAAinD,wBAAjnD,EAA0oD,eAA1oD,EAA0pD,WAA1pD,EAAsqD,YAAtqD,EAAmrD,OAAnrD,EAA2rD,4CAA3rD,EAAwuD,YAAxuD,EAAqvD,QAArvD,EAA8vD,UAA9vD,EAAywD,UAAzwD,EAAoxD,MAApxD,EAA2xD,OAA3xD,EAAmyD,kBAAnyD,EAAszD,YAAtzD,EAAm0D,YAAn0D,EAAg1D,WAAh1D,EAA41D,SAA51D,EAAs2D,QAAt2D,EAA+2D,iCAA/2D,EAAi5D,sBAAj5D,EAAw6D,QAAx6D,EAAi7D,UAAj7D,EAA47D,YAA57D,EAAy8D,YAAz8D,EAAs9D,SAAt9D,EAAg+D,YAAh+D,EAA6+D,SAA7+D,EAAu/D,SAAv/D,EAAigE,OAAjgE,EAAygE,OAAzgE,EAAihE,aAAjhE,EAA+hE,sBAA/hE,EAAsjE,eAAtjE,EAAskE,aAAtkE,EAAolE,WAAplE,EAAgmE,OAAhmE,EAAwmE,SAAxmE,EAAknE,MAAlnE,EAAynE,gBAAznE,EAA0oE,0BAA1oE,EAAqqE,QAArqE,EAA8qE,MAA9qE,EAAqrE,UAArrE,EAAgsE,OAAhsE,EAAwsE,iCAAxsE,EAA0uE,QAA1uE,EAAmvE,kBAAnvE,EAAswE,UAAtwE,EAAixE,MAAjxE,EAAwxE,aAAxxE,EAAsyE,UAAtyE,EAAizE,QAAjzE,EAA0zE,UAA1zE,EAAq0E,aAAr0E,EAAm1E,OAAn1E,EAA21E,SAA31E,EAAq2E,SAAr2E,EAA+2E,oBAA/2E,EAAo4E,QAAp4E,EAA64E,cAA74E,EAA45E,uBAA55E,EAAo7E,aAAp7E,EAAk8E,2BAAl8E,EAA89E,kCAA99E,EAAigF,OAAjgF,EAAygF,YAAzgF,EAAshF,uBAAthF,EAA8iF,cAA9iF,EAA6jF,SAA7jF,EAAukF,QAAvkF,EAAglF,YAAhlF,EAA6lF,cAA7lF,EAA4mF,WAA5mF,EAAwnF,UAAxnF,EAAmoF,UAAnoF,EAA8oF,iBAA9oF,EAAgqF,SAAhqF,EAA0qF,cAA1qF,EAAyrF,8CAAzrF,EAAwuF,OAAxuF,EAAgvF,WAAhvF,EAA4vF,OAA5vF,EAAowF,UAApwF,EAA+wF,wBAA/wF,EAAwyF,WAAxyF,EAAozF,QAApzF,EAA6zF,aAA7zF,EAA20F,sBAA30F,EAAk2F,2BAAl2F,EAA83F,YAA93F,EAA24F,8BAA34F,EAA06F,UAA16F,EAAq7F,aAAr7F,EAAm8F,MAAn8F,EAA08F,SAA18F,EAAo9F,OAAp9F,EAA49F,qBAA59F,EAAk/F,SAAl/F,EAA4/F,QAA5/F,EAAqgG,cAArgG,EAAohG,0BAAphG,EAA+iG,QAA/iG,EAAwjG,QAAxjG,EAAikG,SAAjkG,EAA2kG,sBAA3kG,EAAkmG,gBAAlmG,EAAmnG,eAAnnG,EAAmoG,sCAAnoG,EAA0qG,SAA1qG,EAAorG,YAAprG,EAAisG,SAAjsG,EAA2sG,WAA3sG,EAAutG,UAAvtG,EAAkuG,yBAAluG,EAA4vG,sBAA5vG,EAAmxG,mBAAnxG,EAAuyG,gBAAvyG,EAAwzG,OAAxzG,EAAg0G,QAAh0G,EAAy0G,UAAz0G,CAAjB;;;;;;;;;;;;;;;;;;;;;;;;ACKA,kBAAQ;AACN,MAAI,MAAJ;AACA,wBAFM;AAGN,cAAY,EAAE,kBAAF,EAAZ;CAHF;;;;;;;;;;;;;;;;;;;;;;;ACFA,cAAI,GAAJ;AACA,cAAI,MAAJ,CAAW,KAAX,GAAmB,IAAnB;;AAEA,IAAM,QAAQ;AACZ,SAAO,CAAP;CADI;;AAIN,IAAM,YAAY;AAChB,gCAAW,OAAO;AAChB,UAAM,KAAN,GADgB;GADF;AAIhB,gCAAW,OAAO;AAChB,UAAM,KAAN,GADgB;GAJF;CAAZ;;kBASS,IAAI,eAAK,KAAL,CAAW;AAC5B,cAD4B;AAE5B,sBAF4B;CAAf;;;;;ACnBf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","module.exports = after\n\nfunction after(count, callback, err_cb) {\n    var bail = false\n    err_cb = err_cb || noop\n    proxy.count = count\n\n    return (count === 0) ? callback() : proxy\n\n    function proxy(err, result) {\n        if (proxy.count <= 0) {\n            throw new Error('after called too many times')\n        }\n        --proxy.count\n\n        // after first error, rest are passed to err_cb\n        if (err) {\n            bail = true\n            callback(err)\n            // future error callbacks will go to error handler\n            callback = err_cb\n        } else if (proxy.count === 0 && !bail) {\n            callback(null, result)\n        }\n    }\n}\n\nfunction noop() {}\n","/**\n * An abstraction for slicing an arraybuffer even when\n * ArrayBuffer.prototype.slice is not supported\n *\n * @api public\n */\n\nmodule.exports = function(arraybuffer, start, end) {\n  var bytes = arraybuffer.byteLength;\n  start = start || 0;\n  end = end || bytes;\n\n  if (arraybuffer.slice) { return arraybuffer.slice(start, end); }\n\n  if (start < 0) { start += bytes; }\n  if (end < 0) { end += bytes; }\n  if (end > bytes) { end = bytes; }\n\n  if (start >= bytes || start >= end || bytes === 0) {\n    return new ArrayBuffer(0);\n  }\n\n  var abv = new Uint8Array(arraybuffer);\n  var result = new Uint8Array(end - start);\n  for (var i = start, ii = 0; i < end; i++, ii++) {\n    result[ii] = abv[i];\n  }\n  return result.buffer;\n};\n","module.exports = { \"default\": require(\"core-js/library/fn/symbol\"), __esModule: true };","\"use strict\";\n\nvar _Symbol = require(\"babel-runtime/core-js/symbol\")[\"default\"];\n\nexports[\"default\"] = function (obj) {\n  return obj && obj.constructor === _Symbol ? \"symbol\" : typeof obj;\n};\n\nexports.__esModule = true;","\n/**\n * Expose `Backoff`.\n */\n\nmodule.exports = Backoff;\n\n/**\n * Initialize backoff timer with `opts`.\n *\n * - `min` initial timeout in milliseconds [100]\n * - `max` max timeout [10000]\n * - `jitter` [0]\n * - `factor` [2]\n *\n * @param {Object} opts\n * @api public\n */\n\nfunction Backoff(opts) {\n  opts = opts || {};\n  this.ms = opts.min || 100;\n  this.max = opts.max || 10000;\n  this.factor = opts.factor || 2;\n  this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;\n  this.attempts = 0;\n}\n\n/**\n * Return the backoff duration.\n *\n * @return {Number}\n * @api public\n */\n\nBackoff.prototype.duration = function(){\n  var ms = this.ms * Math.pow(this.factor, this.attempts++);\n  if (this.jitter) {\n    var rand =  Math.random();\n    var deviation = Math.floor(rand * this.jitter * ms);\n    ms = (Math.floor(rand * 10) & 1) == 0  ? ms - deviation : ms + deviation;\n  }\n  return Math.min(ms, this.max) | 0;\n};\n\n/**\n * Reset the number of attempts.\n *\n * @api public\n */\n\nBackoff.prototype.reset = function(){\n  this.attempts = 0;\n};\n\n/**\n * Set the minimum duration\n *\n * @api public\n */\n\nBackoff.prototype.setMin = function(min){\n  this.ms = min;\n};\n\n/**\n * Set the maximum duration\n *\n * @api public\n */\n\nBackoff.prototype.setMax = function(max){\n  this.max = max;\n};\n\n/**\n * Set the jitter\n *\n * @api public\n */\n\nBackoff.prototype.setJitter = function(jitter){\n  this.jitter = jitter;\n};\n\n","/*\n * base64-arraybuffer\n * https://github.com/niklasvh/base64-arraybuffer\n *\n * Copyright (c) 2012 Niklas von Hertzen\n * Licensed under the MIT license.\n */\n(function(chars){\n  \"use strict\";\n\n  exports.encode = function(arraybuffer) {\n    var bytes = new Uint8Array(arraybuffer),\n    i, len = bytes.length, base64 = \"\";\n\n    for (i = 0; i < len; i+=3) {\n      base64 += chars[bytes[i] >> 2];\n      base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n      base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n      base64 += chars[bytes[i + 2] & 63];\n    }\n\n    if ((len % 3) === 2) {\n      base64 = base64.substring(0, base64.length - 1) + \"=\";\n    } else if (len % 3 === 1) {\n      base64 = base64.substring(0, base64.length - 2) + \"==\";\n    }\n\n    return base64;\n  };\n\n  exports.decode =  function(base64) {\n    var bufferLength = base64.length * 0.75,\n    len = base64.length, i, p = 0,\n    encoded1, encoded2, encoded3, encoded4;\n\n    if (base64[base64.length - 1] === \"=\") {\n      bufferLength--;\n      if (base64[base64.length - 2] === \"=\") {\n        bufferLength--;\n      }\n    }\n\n    var arraybuffer = new ArrayBuffer(bufferLength),\n    bytes = new Uint8Array(arraybuffer);\n\n    for (i = 0; i < len; i+=4) {\n      encoded1 = chars.indexOf(base64[i]);\n      encoded2 = chars.indexOf(base64[i+1]);\n      encoded3 = chars.indexOf(base64[i+2]);\n      encoded4 = chars.indexOf(base64[i+3]);\n\n      bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n      bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n      bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n    }\n\n    return arraybuffer;\n  };\n})(\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\");\n","/**\n * Create a blob builder even when vendor prefixes exist\n */\n\nvar BlobBuilder = global.BlobBuilder\n  || global.WebKitBlobBuilder\n  || global.MSBlobBuilder\n  || global.MozBlobBuilder;\n\n/**\n * Check if Blob constructor is supported\n */\n\nvar blobSupported = (function() {\n  try {\n    var a = new Blob(['hi']);\n    return a.size === 2;\n  } catch(e) {\n    return false;\n  }\n})();\n\n/**\n * Check if Blob constructor supports ArrayBufferViews\n * Fails in Safari 6, so we need to map to ArrayBuffers there.\n */\n\nvar blobSupportsArrayBufferView = blobSupported && (function() {\n  try {\n    var b = new Blob([new Uint8Array([1,2])]);\n    return b.size === 2;\n  } catch(e) {\n    return false;\n  }\n})();\n\n/**\n * Check if BlobBuilder is supported\n */\n\nvar blobBuilderSupported = BlobBuilder\n  && BlobBuilder.prototype.append\n  && BlobBuilder.prototype.getBlob;\n\n/**\n * Helper function that maps ArrayBufferViews to ArrayBuffers\n * Used by BlobBuilder constructor and old browsers that didn't\n * support it in the Blob constructor.\n */\n\nfunction mapArrayBufferViews(ary) {\n  for (var i = 0; i < ary.length; i++) {\n    var chunk = ary[i];\n    if (chunk.buffer instanceof ArrayBuffer) {\n      var buf = chunk.buffer;\n\n      // if this is a subarray, make a copy so we only\n      // include the subarray region from the underlying buffer\n      if (chunk.byteLength !== buf.byteLength) {\n        var copy = new Uint8Array(chunk.byteLength);\n        copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));\n        buf = copy.buffer;\n      }\n\n      ary[i] = buf;\n    }\n  }\n}\n\nfunction BlobBuilderConstructor(ary, options) {\n  options = options || {};\n\n  var bb = new BlobBuilder();\n  mapArrayBufferViews(ary);\n\n  for (var i = 0; i < ary.length; i++) {\n    bb.append(ary[i]);\n  }\n\n  return (options.type) ? bb.getBlob(options.type) : bb.getBlob();\n};\n\nfunction BlobConstructor(ary, options) {\n  mapArrayBufferViews(ary);\n  return new Blob(ary, options || {});\n};\n\nmodule.exports = (function() {\n  if (blobSupported) {\n    return blobSupportsArrayBufferView ? global.Blob : BlobConstructor;\n  } else if (blobBuilderSupported) {\n    return BlobBuilderConstructor;\n  } else {\n    return undefined;\n  }\n})();\n","_hmr[\"websocket:null\"].initModule(\"node_modules/browser-resolve/empty.js\", module);\n(function(){\n\n}).apply(this, arguments);\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=","'use strict';\n\nvar has = require('../lib/has');\nvar StrSet = require('../lib/str-set');\nvar forEach = require('lodash/collection/forEach');\nvar some = require('lodash/collection/some');\nvar map = require('lodash/collection/map');\nvar filter = require('lodash/collection/filter');\nvar zipObject = require('lodash/array/zipObject');\nvar forOwn = require('lodash/object/forOwn');\nvar mapValues = require('lodash/object/mapValues');\nvar assign = require('lodash/object/assign');\n\nfunction emitError(err) {\n  setTimeout(function() {\n    throw err;\n  }, 0);\n}\n\nfunction makeModuleIndexesToNames(moduleMeta) {\n  var moduleIndexesToNames = {};\n  forOwn(moduleMeta, function(value, name) {\n    moduleIndexesToNames[value.index] = name;\n  });\n  return moduleIndexesToNames;\n}\n\nvar console = global.console ? global.console : {\n  error: function(){}, log: function() {}\n};\n\nfunction main(\n  moduleDefs, cachedModules, moduleMeta, updateUrl,\n  updateMode, supportModes, ignoreUnaccepted, updateCacheBust, bundleKey,\n  socketio,\n  bundle__filename, bundle__dirname\n) {\n  var moduleIndexesToNames = makeModuleIndexesToNames(moduleMeta);\n\n  var socket;\n  var name, i, len;\n\n  if (!global._hmr[bundleKey].setStatus) {\n    var runtimeModuleInfo = {};\n    var createInfoEntry = function(name) {\n      runtimeModuleInfo[name] = {\n        index: moduleMeta[name].index,\n        hash: moduleMeta[name].hash,\n        parents: new StrSet(moduleMeta[name].parents),\n        module: null,\n        disposeData: null,\n        accepters: new StrSet(),\n        accepting: new StrSet(),\n        decliners: new StrSet(),\n        declining: new StrSet(),\n        selfAcceptCbs: [], // may contain null. nonzero length means module is self-accepting\n        disposeHandlers: []\n      };\n    };\n    for (name in moduleMeta) {\n      if (has(moduleMeta, name)) {\n        createInfoEntry(name);\n      }\n    }\n\n    // loaders take a callback(err, data). They may give null for data if they\n    // know there hasn't been an update.\n    var fileReloaders = {\n      fs: function(cb) {\n        var fs;\n        try {\n          fs = require('f'+'s');\n        } catch(e) {\n          cb(e);\n          return;\n        }\n        fs.readFile(localHmr.updateUrl || bundle__filename, 'utf8', cb);\n      },\n      ajax: function(cb) {\n        var xhr;\n        try {\n          xhr = new XMLHttpRequest();\n        } catch(e) {\n          cb(e);\n          return;\n        }\n        xhr.onreadystatechange = function() {\n          if (xhr.readyState === 4) {\n            if (xhr.status === 200) {\n              cb(null, xhr.responseText);\n            } else {\n              cb(new Error(\"Request had response \"+xhr.status));\n            }\n          }\n        };\n        var url = localHmr.updateUrl + (updateCacheBust?'?_v='+(+new Date()):'');\n        xhr.open('GET', url, true);\n        xhr.send();\n      }\n    };\n\n    var lastScriptData = null;\n\n    // cb(err, expectUpdate)\n    var reloadAndRunScript = function(cb) {\n      if (!has(fileReloaders, localHmr.updateMode)) {\n        cb(new Error(\"updateMode \"+localHmr.updateMode+\" not implemented\"));\n        return;\n      }\n      var reloader = fileReloaders[localHmr.updateMode];\n      reloader(function(err, data) {\n        if (err || !data || lastScriptData === data) {\n          cb(err, false);\n          return;\n        }\n        lastScriptData = data;\n        localHmr.newLoad = null;\n        try {\n          //jshint evil:true\n          if (bundle__filename || bundle__dirname) {\n            new Function('require', '__filename', '__dirname', data)(require, bundle__filename, bundle__dirname);\n          } else {\n            new Function('require', data)(require);\n          }\n          // running the file sets _hmr.newLoad\n        } catch (err2) {\n          localHmr.newLoad = null;\n          cb(err2);\n          return;\n        }\n        if (!localHmr.newLoad) {\n          cb(new Error(\"Reloaded script did not set hot module reload data\"));\n          return;\n        }\n        cb(null, true);\n      });\n    };\n\n    var getOutdatedModules = function() {\n      var outdated = [];\n      var name;\n      // add changed and deleted modules\n      for (name in runtimeModuleInfo) {\n        if (has(runtimeModuleInfo, name)) {\n          if (\n            !has(localHmr.newLoad.moduleMeta, name) ||\n            runtimeModuleInfo[name].hash !== localHmr.newLoad.moduleMeta[name].hash\n          ) {\n            outdated.push(name);\n          }\n        }\n      }\n      // add brand new modules\n      for (name in localHmr.newLoad.moduleMeta) {\n        if (has(localHmr.newLoad.moduleMeta, name)) {\n          if (!has(runtimeModuleInfo, name)) {\n            outdated.push(name);\n          }\n        }\n      }\n      // add modules that are non-accepting/declining parents of outdated modules.\n      // important: if outdated has new elements added during the loop,\n      // then we iterate over them too.\n      for (var i=0; i<outdated.length; i++) {\n        name = outdated[i];\n        //jshint -W083\n        if (has(runtimeModuleInfo, name)) {\n          runtimeModuleInfo[name].parents.forEach(function(parentName) {\n            if (\n              runtimeModuleInfo[name].selfAcceptCbs.length === 0 &&\n              !runtimeModuleInfo[name].accepters.has(parentName) &&\n              !runtimeModuleInfo[name].decliners.has(parentName) &&\n              outdated.indexOf(parentName) === -1\n            ) {\n              outdated.push(parentName);\n            }\n          });\n        }\n      }\n      return outdated;\n    };\n\n    var moduleHotCheck = function(autoApply, cb) {\n      if (typeof autoApply === 'function') {\n        cb = autoApply;\n        autoApply = false;\n      }\n      if (!cb) {\n        throw new Error(\"module.hot.check callback parameter required\");\n      }\n      if (localHmr.status !== 'idle') {\n        cb(new Error(\"module.hot.check can only be called while status is idle\"));\n        return;\n      }\n      if (updateMode === 'websocket') {\n        cb(new Error(\"module.hot.check can't be used when update mode is websocket\"));\n        return;\n      }\n\n      localHmr.setStatus('check');\n      reloadAndRunScript(function(err, expectUpdate) {\n        if (err || !expectUpdate) {\n          localHmr.setStatus('idle');\n          cb(err, null);\n          return;\n        }\n        var outdatedModules = getOutdatedModules();\n        if (outdatedModules.length === 0) {\n          localHmr.setStatus('idle');\n          cb(null, null);\n        } else {\n          localHmr.setStatus('ready');\n          if (autoApply) {\n            moduleHotApply(autoApply, cb);\n          } else {\n            cb(null, outdatedModules);\n          }\n        }\n      });\n    };\n\n    var moduleHotApply = function(options, cb) {\n      if (typeof options === 'function') {\n        cb = options;\n        options = null;\n      }\n      if (!cb) {\n        throw new Error(\"module.hot.apply callback parameter required\");\n      }\n      var ignoreUnaccepted = !!(options && options.ignoreUnaccepted);\n      if (localHmr.status !== 'ready') {\n        cb(new Error(\"module.hot.apply can only be called while status is ready\"));\n        return;\n      }\n\n      var outdatedModules = getOutdatedModules();\n      var isValueNotInOutdatedModules = function(value) {\n        return outdatedModules.indexOf(value) === -1;\n      };\n      var i, len;\n      var acceptedUpdates = filter(outdatedModules, function(name) {\n        if (has(runtimeModuleInfo, name)) {\n          if (\n            runtimeModuleInfo[name].decliners.some(isValueNotInOutdatedModules) ||\n            (\n              runtimeModuleInfo[name].accepters.size() === 0 &&\n              runtimeModuleInfo[name].selfAcceptCbs.length === 0 &&\n              runtimeModuleInfo[name].parents.some(isValueNotInOutdatedModules)\n            )\n          ) {\n            return false;\n          }\n        }\n        return true;\n      });\n      if (!ignoreUnaccepted && outdatedModules.length !== acceptedUpdates.length) {\n        localHmr.setStatus('idle');\n        cb(new Error(\"Some updates were declined\"));\n        return;\n      }\n      var an;\n      for (i=0, len=acceptedUpdates.length; i<len; i++) {\n        an = acceptedUpdates[i];\n        if (has(runtimeModuleInfo, an)) {\n          runtimeModuleInfo[an].disposeData = {};\n          for (var j=0; j<runtimeModuleInfo[an].disposeHandlers.length; j++) {\n            try {\n              runtimeModuleInfo[an].disposeHandlers[j].call(null, runtimeModuleInfo[an].disposeData);\n            } catch(e) {\n              localHmr.setStatus('idle');\n              cb(e || new Error(\"Unknown dispose callback error\"));\n              return;\n            }\n          }\n        }\n      }\n      var selfAccepters = [];\n      for (i=0, len=acceptedUpdates.length; i<len; i++) {\n        an = acceptedUpdates[i];\n        //jshint -W083\n        if (!has(runtimeModuleInfo, an)) {\n          // new modules\n          runtimeModuleInfo[an] = {\n            index: an,\n            hash: localHmr.newLoad.moduleMeta[an].hash,\n            parents: new StrSet(localHmr.newLoad.moduleMeta[an].parents),\n            module: null,\n            disposeData: null,\n            accepters: new StrSet(),\n            accepting: new StrSet(),\n            decliners: new StrSet(),\n            declining: new StrSet(),\n            selfAcceptCbs: [],\n            disposeHandlers: []\n          };\n        } else if (!has(localHmr.newLoad.moduleMeta, an)) {\n          // removed modules\n          delete cachedModules[runtimeModuleInfo[an].index];\n          delete runtimeModuleInfo[an];\n          continue;\n        } else {\n          // updated modules\n          runtimeModuleInfo[an].hash = localHmr.newLoad.moduleMeta[an].hash;\n          runtimeModuleInfo[an].parents = new StrSet(localHmr.newLoad.moduleMeta[an].parents);\n          runtimeModuleInfo[an].module = null;\n          runtimeModuleInfo[an].accepting.forEach(function(accepted) {\n            runtimeModuleInfo[accepted].accepters.del(an);\n          });\n          runtimeModuleInfo[an].accepting = new StrSet();\n          runtimeModuleInfo[an].declining.forEach(function(accepted) {\n            runtimeModuleInfo[accepted].decliners.del(an);\n          });\n          runtimeModuleInfo[an].declining = new StrSet();\n          forEach(runtimeModuleInfo[an].selfAcceptCbs, function(cb) {\n            selfAccepters.push({name: an, cb: cb});\n          });\n          runtimeModuleInfo[an].selfAcceptCbs = [];\n          runtimeModuleInfo[an].disposeHandlers = [];\n        }\n\n        moduleDefs[runtimeModuleInfo[an].index] = [\n          // module function\n          localHmr.newLoad.moduleDefs[localHmr.newLoad.moduleMeta[an].index][0],\n          // module deps\n          mapValues(localHmr.newLoad.moduleDefs[localHmr.newLoad.moduleMeta[an].index][1], function(depIndex, depRef) {\n            var depName = localHmr.newLoad.moduleIndexesToNames[depIndex];\n            if (has(localHmr.runtimeModuleInfo, depName)) {\n              return localHmr.runtimeModuleInfo[depName].index;\n            } else {\n              return depName;\n            }\n          })\n        ];\n        cachedModules[runtimeModuleInfo[an].index] = null;\n      }\n\n      // Update the accept handlers list and call the right ones\n      var errCanWait = null;\n      var updatedNames = new StrSet(acceptedUpdates);\n      var oldUpdateHandlers = localHmr.updateHandlers;\n      var relevantUpdateHandlers = [];\n      var newUpdateHandlers = [];\n      for (i=0, len=oldUpdateHandlers.length; i<len; i++) {\n        if (!updatedNames.has(oldUpdateHandlers[i].accepter)) {\n          newUpdateHandlers.push(oldUpdateHandlers[i]);\n        }\n        if (updatedNames.hasIntersection(oldUpdateHandlers[i].deps)) {\n          relevantUpdateHandlers.push(oldUpdateHandlers[i]);\n        }\n      }\n      localHmr.updateHandlers = newUpdateHandlers;\n      for (i=0, len=relevantUpdateHandlers.length; i<len; i++) {\n        try {\n          relevantUpdateHandlers[i].cb.call(null, acceptedUpdates);\n        } catch(e) {\n          if (errCanWait) emitError(errCanWait);\n          errCanWait = e;\n        }\n      }\n\n      // Call the self-accepting modules\n      forEach(selfAccepters, function(obj) {\n        try {\n          require(runtimeModuleInfo[obj.name].index);\n        } catch(e) {\n          if (obj.cb) {\n            obj.cb.call(null, e);\n          } else {\n            if (errCanWait) emitError(errCanWait);\n            errCanWait = e;\n          }\n        }\n      });\n\n      localHmr.setStatus('idle');\n      cb(errCanWait, acceptedUpdates);\n    };\n\n    var moduleHotSetUpdateMode = function(mode, options) {\n      options = options || {};\n\n      if (supportModes.indexOf(mode) === -1) {\n        throw new Error(\"Mode \"+mode+\" not in supportModes. Please check the Browserify-HMR plugin options.\");\n      }\n      if (mode === 'ajax' && !options.url) {\n        throw new Error(\"url required for ajax update mode\");\n      }\n      if (localHmr.status !== 'idle') {\n        throw new Error(\"module.hot.setUpdateMode can only be called while status is idle\");\n      }\n\n      localHmr.newLoad = null;\n      localHmr.updateMode = updateMode = mode;\n      localHmr.updateUrl = updateUrl = options.url;\n      updateCacheBust = options.cacheBust;\n      ignoreUnaccepted = has(options, 'ignoreUnaccepted') ? options.ignoreUnaccepted : true;\n\n      if (socket) {\n        socket.disconnect();\n        socket = null;\n      }\n      if (mode === 'websocket') {\n        socket = setupSocket();\n      }\n    };\n\n    var setupSocket = function() {\n      var url = updateUrl || 'http://localhost:3123';\n      var socket = socketio(url, {'force new connection': true});\n      console.log('[HMR] Attempting websocket connection to', url);\n\n      var isAcceptingMessages = false;\n      socket.on('connect', function() {\n        isAcceptingMessages = false;\n        var syncMsg = mapValues(runtimeModuleInfo, function(value, name) {\n          return {\n            hash: value.hash\n          };\n        });\n        socket.emit('sync', syncMsg);\n      });\n      var isUpdating = false;\n      var queuedUpdateMessages = [];\n      socket.on('sync confirm', function() {\n        console.log('[HMR] Websocket connection successful.');\n        isAcceptingMessages = true;\n        queuedUpdateMessages = [];\n      });\n      socket.on('disconnect', function() {\n        console.log('[HMR] Websocket connection lost.');\n      });\n      var acceptNewModules = function(msg) {\n        // Make sure we don't accept new modules before we've synced ourselves.\n        if (!isAcceptingMessages) return;\n        if (isUpdating) {\n          queuedUpdateMessages.push(msg);\n          return;\n        }\n        // Take the message and create a localHmr.newLoad value as if the\n        // bundle had been re-executed, then call moduleHotApply.\n        isUpdating = true;\n\n        // random id so we can make the normally unnamed args have random names\n        var rid = String(Math.random()).replace(/[^0-9]/g, '');\n\n        var newModuleDefs = localHmr.newLoad ? localHmr.newLoad.moduleDefs : assign({}, moduleDefs);\n        var newModuleMeta = localHmr.newLoad ?\n          localHmr.newLoad.moduleMeta : mapValues(runtimeModuleInfo, function(value, key) {\n            return {\n              index: value.index,\n              hash: value.hash,\n              parents: value.parents.toArray()\n            };\n          });\n        forOwn(msg.newModuleData, function(value, key) {\n          newModuleMeta[key] = {\n            index: value.index,\n            hash: value.hash,\n            parents: value.parents\n          };\n        });\n        forEach(msg.removedModules, function(removedName) {\n          delete newModuleDefs[runtimeModuleInfo[removedName].index];\n          delete newModuleMeta[removedName];\n        });\n        var newModuleIndexesToNames = makeModuleIndexesToNames(newModuleMeta);\n        forOwn(msg.newModuleData, function(value, key) {\n          // this part needs to run after newModuleMeta and\n          // newModuleIndexesToNames are populated.\n          var newModuleFunction = (function() {\n            var fn;\n            //jshint evil:true\n            if (bundle__filename || bundle__dirname) {\n              fn = new Function('require', 'module', 'exports', '_u1'+rid, '_u2'+rid, '__u3'+rid, '__u4'+rid, '__filename', '__dirname', value.source);\n              return function(require, module, exports, _u1, _u2, _u3, _u4) {\n                global._hmr[bundleKey].initModule(key, module);\n                fn.call(this, require, module, exports, _u1, _u2, _u3, _u4, bundle__filename, bundle__dirname);\n              };\n            } else {\n              fn = new Function('require', 'module', 'exports',  '_u1'+rid, '_u2'+rid, '__u3'+rid, '__u4'+rid, value.source);\n              return function(require, module, exports, _u1, _u2, _u3, _u4) {\n                global._hmr[bundleKey].initModule(key, module);\n                fn.call(this, require, module, exports, _u1, _u2, _u3, _u4);\n              };\n            }\n          })();\n\n          newModuleDefs[newModuleMeta[key].index] = [\n            // module function\n            newModuleFunction,\n            // module deps\n            mapValues(value.deps, function(depIndex, depRef) {\n              var depName = newModuleIndexesToNames[depIndex];\n              if (has(newModuleMeta, depName)) {\n                return newModuleMeta[depName].index;\n              } else {\n                return depName;\n              }\n            })\n          ];\n        });\n        localHmr.newLoad = {\n          moduleDefs: newModuleDefs,\n          moduleMeta: newModuleMeta,\n          moduleIndexesToNames: newModuleIndexesToNames\n        };\n        localHmr.setStatus('ready');\n        var outdatedModules = getOutdatedModules();\n        moduleHotApply({ignoreUnaccepted: ignoreUnaccepted}, function(err, updatedNames) {\n          if (err) {\n            console.error('[HMR] Error applying update', err);\n          }\n          if (updatedNames) {\n            console.log('[HMR] Updated modules', updatedNames);\n            if (outdatedModules.length !== updatedNames.length) {\n              var notUpdatedNames = filter(outdatedModules, function(name) {\n                return updatedNames.indexOf(name) === -1;\n              });\n              console.log('[HMR] Some modules were not updated', notUpdatedNames);\n            }\n          }\n          isUpdating = false;\n          var queuedMsg;\n          while ((queuedMsg = queuedUpdateMessages.shift())) {\n            acceptNewModules(queuedMsg);\n          }\n        });\n      };\n      socket.on('new modules', acceptNewModules);\n      return socket;\n    };\n\n    var localHmr = {\n      updateUrl: updateUrl,\n      updateMode: updateMode,\n      runtimeModuleInfo: runtimeModuleInfo,\n\n      status: \"idle\",\n      setStatus: function(status) {\n        this.status = status;\n        var statusHandlers = this.statusHandlers.slice();\n        for (var i=0, len=statusHandlers.length; i<len; i++) {\n          statusHandlers[i].call(null, status);\n        }\n      },\n      statusHandlers: [],\n      updateHandlers: [],\n\n      // during a reload this is set to an object with moduleDefs,\n      // moduleMeta, and moduleIndexesToNames properties\n      newLoad: null,\n\n      initModule: function(name, module) {\n        runtimeModuleInfo[name].module = module;\n        module.hot = {\n          accept: function(deps, cb) {\n            if (!cb && (!deps || typeof deps === 'function')) { // self\n              cb = deps;\n              deps = null;\n              runtimeModuleInfo[name].selfAcceptCbs.push(cb);\n            } else {\n              if (typeof deps === 'string') {\n                deps = [deps];\n              }\n              var depNames = new StrSet();\n              for (var i=0, depsLen=deps.length; i<depsLen; i++) {\n                var depIndex = moduleDefs[runtimeModuleInfo[name].index][1][deps[i]];\n                if (depIndex === undefined || !has(moduleIndexesToNames, depIndex)) {\n                  throw new Error(\"File does not use dependency: \"+deps[i]);\n                }\n                depNames.add(moduleIndexesToNames[depIndex]);\n              }\n              deps = null;\n              depNames.forEach(function(depName) {\n                runtimeModuleInfo[depName].accepters.add(name);\n                runtimeModuleInfo[name].accepting.add(depName);\n              });\n              if (cb) {\n                localHmr.updateHandlers.push({\n                  accepter: name,\n                  deps: depNames,\n                  cb: cb\n                });\n              }\n            }\n          },\n          decline: function(deps) {\n            if (!deps) { // self\n              runtimeModuleInfo[name].decliners.add(name);\n              runtimeModuleInfo[name].declining.add(name);\n            } else {\n              if (typeof deps === 'string') {\n                deps = [deps];\n              }\n              for (var i=0, depsLen=deps.length; i<depsLen; i++) {\n                var depIndex = moduleDefs[runtimeModuleInfo[name].index][1][deps[i]];\n                if (depIndex === undefined || !has(moduleIndexesToNames, depIndex)) {\n                  throw new Error(\"File does not use dependency: \"+deps[i]);\n                }\n                var depName = moduleIndexesToNames[depIndex];\n                runtimeModuleInfo[depName].decliners.add(name);\n                runtimeModuleInfo[name].declining.add(depName);\n              }\n            }\n          },\n          data: runtimeModuleInfo[name].disposeData,\n          dispose: function(cb) {\n            return this.addDisposeHandler(cb);\n          },\n          addDisposeHandler: function(cb) {\n            runtimeModuleInfo[name].disposeHandlers.push(cb);\n          },\n          removeDisposeHandler: function(cb) {\n            var ix = runtimeModuleInfo[name].disposeHandlers.indexOf(cb);\n            if (ix !== -1) {\n              runtimeModuleInfo[name].disposeHandlers.splice(ix, 1);\n            }\n          },\n\n          // Management\n          check: moduleHotCheck,\n          apply: moduleHotApply,\n          status: function(cb) {\n            if (cb) {\n              return this.addStatusHandler(cb);\n            }\n            return localHmr.status;\n          },\n          addStatusHandler: function(cb) {\n            localHmr.statusHandlers.push(cb);\n          },\n          removeStatusHandler: function(cb) {\n            var ix = localHmr.statusHandlers.indexOf(cb);\n            if (ix !== -1) {\n              localHmr.statusHandlers.splice(ix, 1);\n            }\n          },\n          setUpdateMode: moduleHotSetUpdateMode\n        };\n      }\n    };\n    global._hmr[bundleKey] = localHmr;\n\n    if (updateMode === 'websocket') {\n      socket = setupSocket();\n    }\n    return true;\n  } else { // We're in a reload!\n    global._hmr[bundleKey].newLoad = {\n      moduleDefs: moduleDefs,\n      moduleMeta: moduleMeta,\n      moduleIndexesToNames: moduleIndexesToNames\n    };\n    return false;\n  }\n}\n\nmodule.exports = main;\n","'use strict';\n\nfunction has(object, propName) {\n  return Object.prototype.hasOwnProperty.call(object, propName);\n}\nmodule.exports = has;\n","'use strict';\n\nvar has = require('./has');\n\nfunction StrSet(other) {\n  this._map = {};\n  this._size = 0;\n  if (other) {\n    for (var i=0,len=other.length; i<len; i++) {\n      this.add(other[i]);\n    }\n  }\n}\nStrSet.prototype.add = function(value) {\n  if (!this.has(value)) {\n    this._map[value] = true;\n    this._size++;\n  }\n};\nStrSet.prototype.has = function(value) {\n  return has(this._map, value);\n};\nStrSet.prototype.del = function(value) {\n  if (this.has(value)) {\n    delete this._map[value];\n    this._size--;\n  }\n};\nStrSet.prototype.size = function() {\n  return this._size;\n};\nStrSet.prototype.forEach = function(cb) {\n  for (var value in this._map) {\n    if (has(this._map, value)) {\n      cb(value);\n    }\n  }\n};\nStrSet.prototype.some = function(cb) {\n  for (var value in this._map) {\n    if (has(this._map, value)) {\n      if (cb(value)) {\n        return true;\n      }\n    }\n  }\n  return false;\n};\nStrSet.prototype.every = function(cb) {\n  return !this.some(function(x) {\n    return !cb(x);\n  });\n};\nStrSet.prototype.hasIntersection = function(otherStrSet) {\n  var value;\n  if (this._size < otherStrSet._size) {\n    return this.some(function(value) {\n      return otherStrSet.has(value);\n    });\n  } else {\n    var self = this;\n    return otherStrSet.some(function(value) {\n      return self.has(value);\n    });\n  }\n};\nStrSet.prototype.toArray = function() {\n  var arr = [];\n  this.forEach(function(value) {\n    arr.push(value);\n  });\n  return arr;\n};\n\nmodule.exports = StrSet;\n","/**\n * Slice reference.\n */\n\nvar slice = [].slice;\n\n/**\n * Bind `obj` to `fn`.\n *\n * @param {Object} obj\n * @param {Function|String} fn or string\n * @return {Function}\n * @api public\n */\n\nmodule.exports = function(obj, fn){\n  if ('string' == typeof fn) fn = obj[fn];\n  if ('function' != typeof fn) throw new Error('bind() requires a function');\n  var args = slice.call(arguments, 2);\n  return function(){\n    return fn.apply(obj, args.concat(slice.call(arguments)));\n  }\n};\n","\n/**\n * Expose `Emitter`.\n */\n\nmodule.exports = Emitter;\n\n/**\n * Initialize a new `Emitter`.\n *\n * @api public\n */\n\nfunction Emitter(obj) {\n  if (obj) return mixin(obj);\n};\n\n/**\n * Mixin the emitter properties.\n *\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nfunction mixin(obj) {\n  for (var key in Emitter.prototype) {\n    obj[key] = Emitter.prototype[key];\n  }\n  return obj;\n}\n\n/**\n * Listen on the given `event` with `fn`.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.on =\nEmitter.prototype.addEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n  (this._callbacks[event] = this._callbacks[event] || [])\n    .push(fn);\n  return this;\n};\n\n/**\n * Adds an `event` listener that will be invoked a single\n * time then automatically removed.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.once = function(event, fn){\n  var self = this;\n  this._callbacks = this._callbacks || {};\n\n  function on() {\n    self.off(event, on);\n    fn.apply(this, arguments);\n  }\n\n  on.fn = fn;\n  this.on(event, on);\n  return this;\n};\n\n/**\n * Remove the given callback for `event` or all\n * registered callbacks.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.off =\nEmitter.prototype.removeListener =\nEmitter.prototype.removeAllListeners =\nEmitter.prototype.removeEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n\n  // all\n  if (0 == arguments.length) {\n    this._callbacks = {};\n    return this;\n  }\n\n  // specific event\n  var callbacks = this._callbacks[event];\n  if (!callbacks) return this;\n\n  // remove all handlers\n  if (1 == arguments.length) {\n    delete this._callbacks[event];\n    return this;\n  }\n\n  // remove specific handler\n  var cb;\n  for (var i = 0; i < callbacks.length; i++) {\n    cb = callbacks[i];\n    if (cb === fn || cb.fn === fn) {\n      callbacks.splice(i, 1);\n      break;\n    }\n  }\n  return this;\n};\n\n/**\n * Emit `event` with the given args.\n *\n * @param {String} event\n * @param {Mixed} ...\n * @return {Emitter}\n */\n\nEmitter.prototype.emit = function(event){\n  this._callbacks = this._callbacks || {};\n  var args = [].slice.call(arguments, 1)\n    , callbacks = this._callbacks[event];\n\n  if (callbacks) {\n    callbacks = callbacks.slice(0);\n    for (var i = 0, len = callbacks.length; i < len; ++i) {\n      callbacks[i].apply(this, args);\n    }\n  }\n\n  return this;\n};\n\n/**\n * Return array of callbacks for `event`.\n *\n * @param {String} event\n * @return {Array}\n * @api public\n */\n\nEmitter.prototype.listeners = function(event){\n  this._callbacks = this._callbacks || {};\n  return this._callbacks[event] || [];\n};\n\n/**\n * Check if this emitter has `event` handlers.\n *\n * @param {String} event\n * @return {Boolean}\n * @api public\n */\n\nEmitter.prototype.hasListeners = function(event){\n  return !! this.listeners(event).length;\n};\n","\nmodule.exports = function(a, b){\n  var fn = function(){};\n  fn.prototype = b.prototype;\n  a.prototype = new fn;\n  a.prototype.constructor = a;\n};","require('../../modules/es6.symbol');\nrequire('../../modules/es6.object.to-string');\nmodule.exports = require('../../modules/$.core').Symbol;","module.exports = function(it){\n  if(typeof it != 'function')throw TypeError(it + ' is not a function!');\n  return it;\n};","var isObject = require('./$.is-object');\nmodule.exports = function(it){\n  if(!isObject(it))throw TypeError(it + ' is not an object!');\n  return it;\n};","var toString = {}.toString;\n\nmodule.exports = function(it){\n  return toString.call(it).slice(8, -1);\n};","var core = module.exports = {version: '1.2.6'};\nif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef","// optional / simple context binding\nvar aFunction = require('./$.a-function');\nmodule.exports = function(fn, that, length){\n  aFunction(fn);\n  if(that === undefined)return fn;\n  switch(length){\n    case 1: return function(a){\n      return fn.call(that, a);\n    };\n    case 2: return function(a, b){\n      return fn.call(that, a, b);\n    };\n    case 3: return function(a, b, c){\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function(/* ...args */){\n    return fn.apply(that, arguments);\n  };\n};","// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function(it){\n  if(it == undefined)throw TypeError(\"Can't call method on  \" + it);\n  return it;\n};","// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./$.fails')(function(){\n  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;\n});","// all enumerable object keys, includes symbols\nvar $ = require('./$');\nmodule.exports = function(it){\n  var keys       = $.getKeys(it)\n    , getSymbols = $.getSymbols;\n  if(getSymbols){\n    var symbols = getSymbols(it)\n      , isEnum  = $.isEnum\n      , i       = 0\n      , key;\n    while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))keys.push(key);\n  }\n  return keys;\n};","var global    = require('./$.global')\n  , core      = require('./$.core')\n  , ctx       = require('./$.ctx')\n  , PROTOTYPE = 'prototype';\n\nvar $export = function(type, name, source){\n  var IS_FORCED = type & $export.F\n    , IS_GLOBAL = type & $export.G\n    , IS_STATIC = type & $export.S\n    , IS_PROTO  = type & $export.P\n    , IS_BIND   = type & $export.B\n    , IS_WRAP   = type & $export.W\n    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})\n    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]\n    , key, own, out;\n  if(IS_GLOBAL)source = name;\n  for(key in source){\n    // contains in native\n    own = !IS_FORCED && target && key in target;\n    if(own && key in exports)continue;\n    // export native or passed\n    out = own ? target[key] : source[key];\n    // prevent global pollution for namespaces\n    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n    // bind timers to global for call from export context\n    : IS_BIND && own ? ctx(out, global)\n    // wrap global constructors for prevent change them in library\n    : IS_WRAP && target[key] == out ? (function(C){\n      var F = function(param){\n        return this instanceof C ? new C(param) : C(param);\n      };\n      F[PROTOTYPE] = C[PROTOTYPE];\n      return F;\n    // make static versions for prototype methods\n    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    if(IS_PROTO)(exports[PROTOTYPE] || (exports[PROTOTYPE] = {}))[key] = out;\n  }\n};\n// type bitmap\n$export.F = 1;  // forced\n$export.G = 2;  // global\n$export.S = 4;  // static\n$export.P = 8;  // proto\n$export.B = 16; // bind\n$export.W = 32; // wrap\nmodule.exports = $export;","module.exports = function(exec){\n  try {\n    return !!exec();\n  } catch(e){\n    return true;\n  }\n};","// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nvar toIObject = require('./$.to-iobject')\n  , getNames  = require('./$').getNames\n  , toString  = {}.toString;\n\nvar windowNames = typeof window == 'object' && Object.getOwnPropertyNames\n  ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function(it){\n  try {\n    return getNames(it);\n  } catch(e){\n    return windowNames.slice();\n  }\n};\n\nmodule.exports.get = function getOwnPropertyNames(it){\n  if(windowNames && toString.call(it) == '[object Window]')return getWindowNames(it);\n  return getNames(toIObject(it));\n};","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\nif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function(it, key){\n  return hasOwnProperty.call(it, key);\n};","var $          = require('./$')\n  , createDesc = require('./$.property-desc');\nmodule.exports = require('./$.descriptors') ? function(object, key, value){\n  return $.setDesc(object, key, createDesc(1, value));\n} : function(object, key, value){\n  object[key] = value;\n  return object;\n};","// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = require('./$.cof');\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){\n  return cof(it) == 'String' ? it.split('') : Object(it);\n};","// 7.2.2 IsArray(argument)\nvar cof = require('./$.cof');\nmodule.exports = Array.isArray || function(arg){\n  return cof(arg) == 'Array';\n};","module.exports = function(it){\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};","var $Object = Object;\nmodule.exports = {\n  create:     $Object.create,\n  getProto:   $Object.getPrototypeOf,\n  isEnum:     {}.propertyIsEnumerable,\n  getDesc:    $Object.getOwnPropertyDescriptor,\n  setDesc:    $Object.defineProperty,\n  setDescs:   $Object.defineProperties,\n  getKeys:    $Object.keys,\n  getNames:   $Object.getOwnPropertyNames,\n  getSymbols: $Object.getOwnPropertySymbols,\n  each:       [].forEach\n};","var $         = require('./$')\n  , toIObject = require('./$.to-iobject');\nmodule.exports = function(object, el){\n  var O      = toIObject(object)\n    , keys   = $.getKeys(O)\n    , length = keys.length\n    , index  = 0\n    , key;\n  while(length > index)if(O[key = keys[index++]] === el)return key;\n};","module.exports = true;","module.exports = function(bitmap, value){\n  return {\n    enumerable  : !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable    : !(bitmap & 4),\n    value       : value\n  };\n};","module.exports = require('./$.hide');","var def = require('./$').setDesc\n  , has = require('./$.has')\n  , TAG = require('./$.wks')('toStringTag');\n\nmodule.exports = function(it, tag, stat){\n  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});\n};","var global = require('./$.global')\n  , SHARED = '__core-js_shared__'\n  , store  = global[SHARED] || (global[SHARED] = {});\nmodule.exports = function(key){\n  return store[key] || (store[key] = {});\n};","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./$.iobject')\n  , defined = require('./$.defined');\nmodule.exports = function(it){\n  return IObject(defined(it));\n};","var id = 0\n  , px = Math.random();\nmodule.exports = function(key){\n  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};","var store  = require('./$.shared')('wks')\n  , uid    = require('./$.uid')\n  , Symbol = require('./$.global').Symbol;\nmodule.exports = function(name){\n  return store[name] || (store[name] =\n    Symbol && Symbol[name] || (Symbol || uid)('Symbol.' + name));\n};","_hmr[\"websocket:null\"].initModule(\"node_modules/core-js/library/modules/es6.object.to-string.js\", module);\n(function(){\n\n}).apply(this, arguments);\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=","'use strict';\n// ECMAScript 6 symbols shim\nvar $              = require('./$')\n  , global         = require('./$.global')\n  , has            = require('./$.has')\n  , DESCRIPTORS    = require('./$.descriptors')\n  , $export        = require('./$.export')\n  , redefine       = require('./$.redefine')\n  , $fails         = require('./$.fails')\n  , shared         = require('./$.shared')\n  , setToStringTag = require('./$.set-to-string-tag')\n  , uid            = require('./$.uid')\n  , wks            = require('./$.wks')\n  , keyOf          = require('./$.keyof')\n  , $names         = require('./$.get-names')\n  , enumKeys       = require('./$.enum-keys')\n  , isArray        = require('./$.is-array')\n  , anObject       = require('./$.an-object')\n  , toIObject      = require('./$.to-iobject')\n  , createDesc     = require('./$.property-desc')\n  , getDesc        = $.getDesc\n  , setDesc        = $.setDesc\n  , _create        = $.create\n  , getNames       = $names.get\n  , $Symbol        = global.Symbol\n  , $JSON          = global.JSON\n  , _stringify     = $JSON && $JSON.stringify\n  , setter         = false\n  , HIDDEN         = wks('_hidden')\n  , isEnum         = $.isEnum\n  , SymbolRegistry = shared('symbol-registry')\n  , AllSymbols     = shared('symbols')\n  , useNative      = typeof $Symbol == 'function'\n  , ObjectProto    = Object.prototype;\n\n// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687\nvar setSymbolDesc = DESCRIPTORS && $fails(function(){\n  return _create(setDesc({}, 'a', {\n    get: function(){ return setDesc(this, 'a', {value: 7}).a; }\n  })).a != 7;\n}) ? function(it, key, D){\n  var protoDesc = getDesc(ObjectProto, key);\n  if(protoDesc)delete ObjectProto[key];\n  setDesc(it, key, D);\n  if(protoDesc && it !== ObjectProto)setDesc(ObjectProto, key, protoDesc);\n} : setDesc;\n\nvar wrap = function(tag){\n  var sym = AllSymbols[tag] = _create($Symbol.prototype);\n  sym._k = tag;\n  DESCRIPTORS && setter && setSymbolDesc(ObjectProto, tag, {\n    configurable: true,\n    set: function(value){\n      if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;\n      setSymbolDesc(this, tag, createDesc(1, value));\n    }\n  });\n  return sym;\n};\n\nvar isSymbol = function(it){\n  return typeof it == 'symbol';\n};\n\nvar $defineProperty = function defineProperty(it, key, D){\n  if(D && has(AllSymbols, key)){\n    if(!D.enumerable){\n      if(!has(it, HIDDEN))setDesc(it, HIDDEN, createDesc(1, {}));\n      it[HIDDEN][key] = true;\n    } else {\n      if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;\n      D = _create(D, {enumerable: createDesc(0, false)});\n    } return setSymbolDesc(it, key, D);\n  } return setDesc(it, key, D);\n};\nvar $defineProperties = function defineProperties(it, P){\n  anObject(it);\n  var keys = enumKeys(P = toIObject(P))\n    , i    = 0\n    , l = keys.length\n    , key;\n  while(l > i)$defineProperty(it, key = keys[i++], P[key]);\n  return it;\n};\nvar $create = function create(it, P){\n  return P === undefined ? _create(it) : $defineProperties(_create(it), P);\n};\nvar $propertyIsEnumerable = function propertyIsEnumerable(key){\n  var E = isEnum.call(this, key);\n  return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key]\n    ? E : true;\n};\nvar $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){\n  var D = getDesc(it = toIObject(it), key);\n  if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;\n  return D;\n};\nvar $getOwnPropertyNames = function getOwnPropertyNames(it){\n  var names  = getNames(toIObject(it))\n    , result = []\n    , i      = 0\n    , key;\n  while(names.length > i)if(!has(AllSymbols, key = names[i++]) && key != HIDDEN)result.push(key);\n  return result;\n};\nvar $getOwnPropertySymbols = function getOwnPropertySymbols(it){\n  var names  = getNames(toIObject(it))\n    , result = []\n    , i      = 0\n    , key;\n  while(names.length > i)if(has(AllSymbols, key = names[i++]))result.push(AllSymbols[key]);\n  return result;\n};\nvar $stringify = function stringify(it){\n  if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined\n  var args = [it]\n    , i    = 1\n    , $$   = arguments\n    , replacer, $replacer;\n  while($$.length > i)args.push($$[i++]);\n  replacer = args[1];\n  if(typeof replacer == 'function')$replacer = replacer;\n  if($replacer || !isArray(replacer))replacer = function(key, value){\n    if($replacer)value = $replacer.call(this, key, value);\n    if(!isSymbol(value))return value;\n  };\n  args[1] = replacer;\n  return _stringify.apply($JSON, args);\n};\nvar buggyJSON = $fails(function(){\n  var S = $Symbol();\n  // MS Edge converts symbol values to JSON as {}\n  // WebKit converts symbol values to JSON as null\n  // V8 throws on boxed symbols\n  return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}';\n});\n\n// 19.4.1.1 Symbol([description])\nif(!useNative){\n  $Symbol = function Symbol(){\n    if(isSymbol(this))throw TypeError('Symbol is not a constructor');\n    return wrap(uid(arguments.length > 0 ? arguments[0] : undefined));\n  };\n  redefine($Symbol.prototype, 'toString', function toString(){\n    return this._k;\n  });\n\n  isSymbol = function(it){\n    return it instanceof $Symbol;\n  };\n\n  $.create     = $create;\n  $.isEnum     = $propertyIsEnumerable;\n  $.getDesc    = $getOwnPropertyDescriptor;\n  $.setDesc    = $defineProperty;\n  $.setDescs   = $defineProperties;\n  $.getNames   = $names.get = $getOwnPropertyNames;\n  $.getSymbols = $getOwnPropertySymbols;\n\n  if(DESCRIPTORS && !require('./$.library')){\n    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);\n  }\n}\n\nvar symbolStatics = {\n  // 19.4.2.1 Symbol.for(key)\n  'for': function(key){\n    return has(SymbolRegistry, key += '')\n      ? SymbolRegistry[key]\n      : SymbolRegistry[key] = $Symbol(key);\n  },\n  // 19.4.2.5 Symbol.keyFor(sym)\n  keyFor: function keyFor(key){\n    return keyOf(SymbolRegistry, key);\n  },\n  useSetter: function(){ setter = true; },\n  useSimple: function(){ setter = false; }\n};\n// 19.4.2.2 Symbol.hasInstance\n// 19.4.2.3 Symbol.isConcatSpreadable\n// 19.4.2.4 Symbol.iterator\n// 19.4.2.6 Symbol.match\n// 19.4.2.8 Symbol.replace\n// 19.4.2.9 Symbol.search\n// 19.4.2.10 Symbol.species\n// 19.4.2.11 Symbol.split\n// 19.4.2.12 Symbol.toPrimitive\n// 19.4.2.13 Symbol.toStringTag\n// 19.4.2.14 Symbol.unscopables\n$.each.call((\n  'hasInstance,isConcatSpreadable,iterator,match,replace,search,' +\n  'species,split,toPrimitive,toStringTag,unscopables'\n).split(','), function(it){\n  var sym = wks(it);\n  symbolStatics[it] = useNative ? sym : wrap(sym);\n});\n\nsetter = true;\n\n$export($export.G + $export.W, {Symbol: $Symbol});\n\n$export($export.S, 'Symbol', symbolStatics);\n\n$export($export.S + $export.F * !useNative, 'Object', {\n  // 19.1.2.2 Object.create(O [, Properties])\n  create: $create,\n  // 19.1.2.4 Object.defineProperty(O, P, Attributes)\n  defineProperty: $defineProperty,\n  // 19.1.2.3 Object.defineProperties(O, Properties)\n  defineProperties: $defineProperties,\n  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)\n  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,\n  // 19.1.2.7 Object.getOwnPropertyNames(O)\n  getOwnPropertyNames: $getOwnPropertyNames,\n  // 19.1.2.8 Object.getOwnPropertySymbols(O)\n  getOwnPropertySymbols: $getOwnPropertySymbols\n});\n\n// 24.3.2 JSON.stringify(value [, replacer [, space]])\n$JSON && $export($export.S + $export.F * (!useNative || buggyJSON), 'JSON', {stringify: $stringify});\n\n// 19.4.3.5 Symbol.prototype[@@toStringTag]\nsetToStringTag($Symbol, 'Symbol');\n// 20.2.1.9 Math[@@toStringTag]\nsetToStringTag(Math, 'Math', true);\n// 24.3.3 JSON[@@toStringTag]\nsetToStringTag(global.JSON, 'JSON', true);","\n/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n               && 'undefined' != typeof chrome.storage\n                  ? chrome.storage.local\n                  : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n  'lightseagreen',\n  'forestgreen',\n  'goldenrod',\n  'dodgerblue',\n  'darkorchid',\n  'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n  // is webkit? http://stackoverflow.com/a/16459606/376773\n  return ('WebkitAppearance' in document.documentElement.style) ||\n    // is firebug? http://stackoverflow.com/a/398120/376773\n    (window.console && (console.firebug || (console.exception && console.table))) ||\n    // is firefox >= v31?\n    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n    (navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31);\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n  return JSON.stringify(v);\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs() {\n  var args = arguments;\n  var useColors = this.useColors;\n\n  args[0] = (useColors ? '%c' : '')\n    + this.namespace\n    + (useColors ? ' %c' : ' ')\n    + args[0]\n    + (useColors ? '%c ' : ' ')\n    + '+' + exports.humanize(this.diff);\n\n  if (!useColors) return args;\n\n  var c = 'color: ' + this.color;\n  args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1));\n\n  // the final \"%c\" is somewhat tricky, because there could be other\n  // arguments passed either before or after the %c, so we need to\n  // figure out the correct index to insert the CSS into\n  var index = 0;\n  var lastC = 0;\n  args[0].replace(/%[a-z%]/g, function(match) {\n    if ('%%' === match) return;\n    index++;\n    if ('%c' === match) {\n      // we only are interested in the *last* %c\n      // (the user may have provided their own)\n      lastC = index;\n    }\n  });\n\n  args.splice(lastC, 0, c);\n  return args;\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n  // this hackery is required for IE8/9, where\n  // the `console.log` function doesn't have 'apply'\n  return 'object' === typeof console\n    && console.log\n    && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n  try {\n    if (null == namespaces) {\n      exports.storage.removeItem('debug');\n    } else {\n      exports.storage.debug = namespaces;\n    }\n  } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n  var r;\n  try {\n    r = exports.storage.debug;\n  } catch(e) {}\n  return r;\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage(){\n  try {\n    return window.localStorage;\n  } catch (e) {}\n}\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = debug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lowercased letter, i.e. \"n\".\n */\n\nexports.formatters = {};\n\n/**\n * Previously assigned color.\n */\n\nvar prevColor = 0;\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n *\n * @return {Number}\n * @api private\n */\n\nfunction selectColor() {\n  return exports.colors[prevColor++ % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction debug(namespace) {\n\n  // define the `disabled` version\n  function disabled() {\n  }\n  disabled.enabled = false;\n\n  // define the `enabled` version\n  function enabled() {\n\n    var self = enabled;\n\n    // set `diff` timestamp\n    var curr = +new Date();\n    var ms = curr - (prevTime || curr);\n    self.diff = ms;\n    self.prev = prevTime;\n    self.curr = curr;\n    prevTime = curr;\n\n    // add the `color` if not set\n    if (null == self.useColors) self.useColors = exports.useColors();\n    if (null == self.color && self.useColors) self.color = selectColor();\n\n    var args = Array.prototype.slice.call(arguments);\n\n    args[0] = exports.coerce(args[0]);\n\n    if ('string' !== typeof args[0]) {\n      // anything else let's inspect with %o\n      args = ['%o'].concat(args);\n    }\n\n    // apply any `formatters` transformations\n    var index = 0;\n    args[0] = args[0].replace(/%([a-z%])/g, function(match, format) {\n      // if we encounter an escaped % then don't increase the array index\n      if (match === '%%') return match;\n      index++;\n      var formatter = exports.formatters[format];\n      if ('function' === typeof formatter) {\n        var val = args[index];\n        match = formatter.call(self, val);\n\n        // now we need to remove `args[index]` since it's inlined in the `format`\n        args.splice(index, 1);\n        index--;\n      }\n      return match;\n    });\n\n    if ('function' === typeof exports.formatArgs) {\n      args = exports.formatArgs.apply(self, args);\n    }\n    var logFn = enabled.log || exports.log || console.log.bind(console);\n    logFn.apply(self, args);\n  }\n  enabled.enabled = true;\n\n  var fn = exports.enabled(namespace) ? enabled : disabled;\n\n  fn.namespace = namespace;\n\n  return fn;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n  exports.save(namespaces);\n\n  var split = (namespaces || '').split(/[\\s,]+/);\n  var len = split.length;\n\n  for (var i = 0; i < len; i++) {\n    if (!split[i]) continue; // ignore empty strings\n    namespaces = split[i].replace(/\\*/g, '.*?');\n    if (namespaces[0] === '-') {\n      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n    } else {\n      exports.names.push(new RegExp('^' + namespaces + '$'));\n    }\n  }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n  exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n  var i, len;\n  for (i = 0, len = exports.skips.length; i < len; i++) {\n    if (exports.skips[i].test(name)) {\n      return false;\n    }\n  }\n  for (i = 0, len = exports.names.length; i < len; i++) {\n    if (exports.names[i].test(name)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n  if (val instanceof Error) return val.stack || val.message;\n  return val;\n}\n","\nmodule.exports =  require('./lib/');\n","\nmodule.exports = require('./socket');\n\n/**\n * Exports parser\n *\n * @api public\n *\n */\nmodule.exports.parser = require('engine.io-parser');\n","/**\n * Module dependencies.\n */\n\nvar transports = require('./transports');\nvar Emitter = require('component-emitter');\nvar debug = require('debug')('engine.io-client:socket');\nvar index = require('indexof');\nvar parser = require('engine.io-parser');\nvar parseuri = require('parseuri');\nvar parsejson = require('parsejson');\nvar parseqs = require('parseqs');\n\n/**\n * Module exports.\n */\n\nmodule.exports = Socket;\n\n/**\n * Noop function.\n *\n * @api private\n */\n\nfunction noop(){}\n\n/**\n * Socket constructor.\n *\n * @param {String|Object} uri or options\n * @param {Object} options\n * @api public\n */\n\nfunction Socket(uri, opts){\n  if (!(this instanceof Socket)) return new Socket(uri, opts);\n\n  opts = opts || {};\n\n  if (uri && 'object' == typeof uri) {\n    opts = uri;\n    uri = null;\n  }\n\n  if (uri) {\n    uri = parseuri(uri);\n    opts.hostname = uri.host;\n    opts.secure = uri.protocol == 'https' || uri.protocol == 'wss';\n    opts.port = uri.port;\n    if (uri.query) opts.query = uri.query;\n  } else if (opts.host) {\n    opts.hostname = parseuri(opts.host).host;\n  }\n\n  this.secure = null != opts.secure ? opts.secure :\n    (global.location && 'https:' == location.protocol);\n\n  if (opts.hostname && !opts.port) {\n    // if no port is specified manually, use the protocol default\n    opts.port = this.secure ? '443' : '80';\n  }\n\n  this.agent = opts.agent || false;\n  this.hostname = opts.hostname ||\n    (global.location ? location.hostname : 'localhost');\n  this.port = opts.port || (global.location && location.port ?\n       location.port :\n       (this.secure ? 443 : 80));\n  this.query = opts.query || {};\n  if ('string' == typeof this.query) this.query = parseqs.decode(this.query);\n  this.upgrade = false !== opts.upgrade;\n  this.path = (opts.path || '/engine.io').replace(/\\/$/, '') + '/';\n  this.forceJSONP = !!opts.forceJSONP;\n  this.jsonp = false !== opts.jsonp;\n  this.forceBase64 = !!opts.forceBase64;\n  this.enablesXDR = !!opts.enablesXDR;\n  this.timestampParam = opts.timestampParam || 't';\n  this.timestampRequests = opts.timestampRequests;\n  this.transports = opts.transports || ['polling', 'websocket'];\n  this.readyState = '';\n  this.writeBuffer = [];\n  this.policyPort = opts.policyPort || 843;\n  this.rememberUpgrade = opts.rememberUpgrade || false;\n  this.binaryType = null;\n  this.onlyBinaryUpgrades = opts.onlyBinaryUpgrades;\n  this.perMessageDeflate = false !== opts.perMessageDeflate ? (opts.perMessageDeflate || {}) : false;\n\n  if (true === this.perMessageDeflate) this.perMessageDeflate = {};\n  if (this.perMessageDeflate && null == this.perMessageDeflate.threshold) {\n    this.perMessageDeflate.threshold = 1024;\n  }\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx || null;\n  this.key = opts.key || null;\n  this.passphrase = opts.passphrase || null;\n  this.cert = opts.cert || null;\n  this.ca = opts.ca || null;\n  this.ciphers = opts.ciphers || null;\n  this.rejectUnauthorized = opts.rejectUnauthorized === undefined ? null : opts.rejectUnauthorized;\n\n  // other options for Node.js client\n  var freeGlobal = typeof global == 'object' && global;\n  if (freeGlobal.global === freeGlobal) {\n    if (opts.extraHeaders && Object.keys(opts.extraHeaders).length > 0) {\n      this.extraHeaders = opts.extraHeaders;\n    }\n  }\n\n  this.open();\n}\n\nSocket.priorWebsocketSuccess = false;\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Socket.prototype);\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nSocket.protocol = parser.protocol; // this is an int\n\n/**\n * Expose deps for legacy compatibility\n * and standalone browser access.\n */\n\nSocket.Socket = Socket;\nSocket.Transport = require('./transport');\nSocket.transports = require('./transports');\nSocket.parser = require('engine.io-parser');\n\n/**\n * Creates transport of the given type.\n *\n * @param {String} transport name\n * @return {Transport}\n * @api private\n */\n\nSocket.prototype.createTransport = function (name) {\n  debug('creating transport \"%s\"', name);\n  var query = clone(this.query);\n\n  // append engine.io protocol identifier\n  query.EIO = parser.protocol;\n\n  // transport name\n  query.transport = name;\n\n  // session id if we already have one\n  if (this.id) query.sid = this.id;\n\n  var transport = new transports[name]({\n    agent: this.agent,\n    hostname: this.hostname,\n    port: this.port,\n    secure: this.secure,\n    path: this.path,\n    query: query,\n    forceJSONP: this.forceJSONP,\n    jsonp: this.jsonp,\n    forceBase64: this.forceBase64,\n    enablesXDR: this.enablesXDR,\n    timestampRequests: this.timestampRequests,\n    timestampParam: this.timestampParam,\n    policyPort: this.policyPort,\n    socket: this,\n    pfx: this.pfx,\n    key: this.key,\n    passphrase: this.passphrase,\n    cert: this.cert,\n    ca: this.ca,\n    ciphers: this.ciphers,\n    rejectUnauthorized: this.rejectUnauthorized,\n    perMessageDeflate: this.perMessageDeflate,\n    extraHeaders: this.extraHeaders\n  });\n\n  return transport;\n};\n\nfunction clone (obj) {\n  var o = {};\n  for (var i in obj) {\n    if (obj.hasOwnProperty(i)) {\n      o[i] = obj[i];\n    }\n  }\n  return o;\n}\n\n/**\n * Initializes transport to use and starts probe.\n *\n * @api private\n */\nSocket.prototype.open = function () {\n  var transport;\n  if (this.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf('websocket') != -1) {\n    transport = 'websocket';\n  } else if (0 === this.transports.length) {\n    // Emit error on next tick so it can be listened to\n    var self = this;\n    setTimeout(function() {\n      self.emit('error', 'No transports available');\n    }, 0);\n    return;\n  } else {\n    transport = this.transports[0];\n  }\n  this.readyState = 'opening';\n\n  // Retry with the next transport if the transport is disabled (jsonp: false)\n  try {\n    transport = this.createTransport(transport);\n  } catch (e) {\n    this.transports.shift();\n    this.open();\n    return;\n  }\n\n  transport.open();\n  this.setTransport(transport);\n};\n\n/**\n * Sets the current transport. Disables the existing one (if any).\n *\n * @api private\n */\n\nSocket.prototype.setTransport = function(transport){\n  debug('setting transport %s', transport.name);\n  var self = this;\n\n  if (this.transport) {\n    debug('clearing existing transport %s', this.transport.name);\n    this.transport.removeAllListeners();\n  }\n\n  // set up transport\n  this.transport = transport;\n\n  // set up transport listeners\n  transport\n  .on('drain', function(){\n    self.onDrain();\n  })\n  .on('packet', function(packet){\n    self.onPacket(packet);\n  })\n  .on('error', function(e){\n    self.onError(e);\n  })\n  .on('close', function(){\n    self.onClose('transport close');\n  });\n};\n\n/**\n * Probes a transport.\n *\n * @param {String} transport name\n * @api private\n */\n\nSocket.prototype.probe = function (name) {\n  debug('probing transport \"%s\"', name);\n  var transport = this.createTransport(name, { probe: 1 })\n    , failed = false\n    , self = this;\n\n  Socket.priorWebsocketSuccess = false;\n\n  function onTransportOpen(){\n    if (self.onlyBinaryUpgrades) {\n      var upgradeLosesBinary = !this.supportsBinary && self.transport.supportsBinary;\n      failed = failed || upgradeLosesBinary;\n    }\n    if (failed) return;\n\n    debug('probe transport \"%s\" opened', name);\n    transport.send([{ type: 'ping', data: 'probe' }]);\n    transport.once('packet', function (msg) {\n      if (failed) return;\n      if ('pong' == msg.type && 'probe' == msg.data) {\n        debug('probe transport \"%s\" pong', name);\n        self.upgrading = true;\n        self.emit('upgrading', transport);\n        if (!transport) return;\n        Socket.priorWebsocketSuccess = 'websocket' == transport.name;\n\n        debug('pausing current transport \"%s\"', self.transport.name);\n        self.transport.pause(function () {\n          if (failed) return;\n          if ('closed' == self.readyState) return;\n          debug('changing transport and sending upgrade packet');\n\n          cleanup();\n\n          self.setTransport(transport);\n          transport.send([{ type: 'upgrade' }]);\n          self.emit('upgrade', transport);\n          transport = null;\n          self.upgrading = false;\n          self.flush();\n        });\n      } else {\n        debug('probe transport \"%s\" failed', name);\n        var err = new Error('probe error');\n        err.transport = transport.name;\n        self.emit('upgradeError', err);\n      }\n    });\n  }\n\n  function freezeTransport() {\n    if (failed) return;\n\n    // Any callback called by transport should be ignored since now\n    failed = true;\n\n    cleanup();\n\n    transport.close();\n    transport = null;\n  }\n\n  //Handle any error that happens while probing\n  function onerror(err) {\n    var error = new Error('probe error: ' + err);\n    error.transport = transport.name;\n\n    freezeTransport();\n\n    debug('probe transport \"%s\" failed because of error: %s', name, err);\n\n    self.emit('upgradeError', error);\n  }\n\n  function onTransportClose(){\n    onerror(\"transport closed\");\n  }\n\n  //When the socket is closed while we're probing\n  function onclose(){\n    onerror(\"socket closed\");\n  }\n\n  //When the socket is upgraded while we're probing\n  function onupgrade(to){\n    if (transport && to.name != transport.name) {\n      debug('\"%s\" works - aborting \"%s\"', to.name, transport.name);\n      freezeTransport();\n    }\n  }\n\n  //Remove all listeners on the transport and on self\n  function cleanup(){\n    transport.removeListener('open', onTransportOpen);\n    transport.removeListener('error', onerror);\n    transport.removeListener('close', onTransportClose);\n    self.removeListener('close', onclose);\n    self.removeListener('upgrading', onupgrade);\n  }\n\n  transport.once('open', onTransportOpen);\n  transport.once('error', onerror);\n  transport.once('close', onTransportClose);\n\n  this.once('close', onclose);\n  this.once('upgrading', onupgrade);\n\n  transport.open();\n\n};\n\n/**\n * Called when connection is deemed open.\n *\n * @api public\n */\n\nSocket.prototype.onOpen = function () {\n  debug('socket open');\n  this.readyState = 'open';\n  Socket.priorWebsocketSuccess = 'websocket' == this.transport.name;\n  this.emit('open');\n  this.flush();\n\n  // we check for `readyState` in case an `open`\n  // listener already closed the socket\n  if ('open' == this.readyState && this.upgrade && this.transport.pause) {\n    debug('starting upgrade probes');\n    for (var i = 0, l = this.upgrades.length; i < l; i++) {\n      this.probe(this.upgrades[i]);\n    }\n  }\n};\n\n/**\n * Handles a packet.\n *\n * @api private\n */\n\nSocket.prototype.onPacket = function (packet) {\n  if ('opening' == this.readyState || 'open' == this.readyState) {\n    debug('socket receive: type \"%s\", data \"%s\"', packet.type, packet.data);\n\n    this.emit('packet', packet);\n\n    // Socket is live - any packet counts\n    this.emit('heartbeat');\n\n    switch (packet.type) {\n      case 'open':\n        this.onHandshake(parsejson(packet.data));\n        break;\n\n      case 'pong':\n        this.setPing();\n        this.emit('pong');\n        break;\n\n      case 'error':\n        var err = new Error('server error');\n        err.code = packet.data;\n        this.onError(err);\n        break;\n\n      case 'message':\n        this.emit('data', packet.data);\n        this.emit('message', packet.data);\n        break;\n    }\n  } else {\n    debug('packet received with socket readyState \"%s\"', this.readyState);\n  }\n};\n\n/**\n * Called upon handshake completion.\n *\n * @param {Object} handshake obj\n * @api private\n */\n\nSocket.prototype.onHandshake = function (data) {\n  this.emit('handshake', data);\n  this.id = data.sid;\n  this.transport.query.sid = data.sid;\n  this.upgrades = this.filterUpgrades(data.upgrades);\n  this.pingInterval = data.pingInterval;\n  this.pingTimeout = data.pingTimeout;\n  this.onOpen();\n  // In case open handler closes socket\n  if  ('closed' == this.readyState) return;\n  this.setPing();\n\n  // Prolong liveness of socket on heartbeat\n  this.removeListener('heartbeat', this.onHeartbeat);\n  this.on('heartbeat', this.onHeartbeat);\n};\n\n/**\n * Resets ping timeout.\n *\n * @api private\n */\n\nSocket.prototype.onHeartbeat = function (timeout) {\n  clearTimeout(this.pingTimeoutTimer);\n  var self = this;\n  self.pingTimeoutTimer = setTimeout(function () {\n    if ('closed' == self.readyState) return;\n    self.onClose('ping timeout');\n  }, timeout || (self.pingInterval + self.pingTimeout));\n};\n\n/**\n * Pings server every `this.pingInterval` and expects response\n * within `this.pingTimeout` or closes connection.\n *\n * @api private\n */\n\nSocket.prototype.setPing = function () {\n  var self = this;\n  clearTimeout(self.pingIntervalTimer);\n  self.pingIntervalTimer = setTimeout(function () {\n    debug('writing ping packet - expecting pong within %sms', self.pingTimeout);\n    self.ping();\n    self.onHeartbeat(self.pingTimeout);\n  }, self.pingInterval);\n};\n\n/**\n* Sends a ping packet.\n*\n* @api private\n*/\n\nSocket.prototype.ping = function () {\n  var self = this;\n  this.sendPacket('ping', function(){\n    self.emit('ping');\n  });\n};\n\n/**\n * Called on `drain` event\n *\n * @api private\n */\n\nSocket.prototype.onDrain = function() {\n  this.writeBuffer.splice(0, this.prevBufferLen);\n\n  // setting prevBufferLen = 0 is very important\n  // for example, when upgrading, upgrade packet is sent over,\n  // and a nonzero prevBufferLen could cause problems on `drain`\n  this.prevBufferLen = 0;\n\n  if (0 === this.writeBuffer.length) {\n    this.emit('drain');\n  } else {\n    this.flush();\n  }\n};\n\n/**\n * Flush write buffers.\n *\n * @api private\n */\n\nSocket.prototype.flush = function () {\n  if ('closed' != this.readyState && this.transport.writable &&\n    !this.upgrading && this.writeBuffer.length) {\n    debug('flushing %d packets in socket', this.writeBuffer.length);\n    this.transport.send(this.writeBuffer);\n    // keep track of current length of writeBuffer\n    // splice writeBuffer and callbackBuffer on `drain`\n    this.prevBufferLen = this.writeBuffer.length;\n    this.emit('flush');\n  }\n};\n\n/**\n * Sends a message.\n *\n * @param {String} message.\n * @param {Function} callback function.\n * @param {Object} options.\n * @return {Socket} for chaining.\n * @api public\n */\n\nSocket.prototype.write =\nSocket.prototype.send = function (msg, options, fn) {\n  this.sendPacket('message', msg, options, fn);\n  return this;\n};\n\n/**\n * Sends a packet.\n *\n * @param {String} packet type.\n * @param {String} data.\n * @param {Object} options.\n * @param {Function} callback function.\n * @api private\n */\n\nSocket.prototype.sendPacket = function (type, data, options, fn) {\n  if('function' == typeof data) {\n    fn = data;\n    data = undefined;\n  }\n\n  if ('function' == typeof options) {\n    fn = options;\n    options = null;\n  }\n\n  if ('closing' == this.readyState || 'closed' == this.readyState) {\n    return;\n  }\n\n  options = options || {};\n  options.compress = false !== options.compress;\n\n  var packet = {\n    type: type,\n    data: data,\n    options: options\n  };\n  this.emit('packetCreate', packet);\n  this.writeBuffer.push(packet);\n  if (fn) this.once('flush', fn);\n  this.flush();\n};\n\n/**\n * Closes the connection.\n *\n * @api private\n */\n\nSocket.prototype.close = function () {\n  if ('opening' == this.readyState || 'open' == this.readyState) {\n    this.readyState = 'closing';\n\n    var self = this;\n\n    if (this.writeBuffer.length) {\n      this.once('drain', function() {\n        if (this.upgrading) {\n          waitForUpgrade();\n        } else {\n          close();\n        }\n      });\n    } else if (this.upgrading) {\n      waitForUpgrade();\n    } else {\n      close();\n    }\n  }\n\n  function close() {\n    self.onClose('forced close');\n    debug('socket closing - telling transport to close');\n    self.transport.close();\n  }\n\n  function cleanupAndClose() {\n    self.removeListener('upgrade', cleanupAndClose);\n    self.removeListener('upgradeError', cleanupAndClose);\n    close();\n  }\n\n  function waitForUpgrade() {\n    // wait for upgrade to finish since we can't send packets while pausing a transport\n    self.once('upgrade', cleanupAndClose);\n    self.once('upgradeError', cleanupAndClose);\n  }\n\n  return this;\n};\n\n/**\n * Called upon transport error\n *\n * @api private\n */\n\nSocket.prototype.onError = function (err) {\n  debug('socket error %j', err);\n  Socket.priorWebsocketSuccess = false;\n  this.emit('error', err);\n  this.onClose('transport error', err);\n};\n\n/**\n * Called upon transport close.\n *\n * @api private\n */\n\nSocket.prototype.onClose = function (reason, desc) {\n  if ('opening' == this.readyState || 'open' == this.readyState || 'closing' == this.readyState) {\n    debug('socket close with reason: \"%s\"', reason);\n    var self = this;\n\n    // clear timers\n    clearTimeout(this.pingIntervalTimer);\n    clearTimeout(this.pingTimeoutTimer);\n\n    // stop event from firing again for transport\n    this.transport.removeAllListeners('close');\n\n    // ensure transport won't stay open\n    this.transport.close();\n\n    // ignore further transport communication\n    this.transport.removeAllListeners();\n\n    // set ready state\n    this.readyState = 'closed';\n\n    // clear session id\n    this.id = null;\n\n    // emit close event\n    this.emit('close', reason, desc);\n\n    // clean buffers after, so users can still\n    // grab the buffers on `close` event\n    self.writeBuffer = [];\n    self.prevBufferLen = 0;\n  }\n};\n\n/**\n * Filters upgrades, returning only those matching client transports.\n *\n * @param {Array} server upgrades\n * @api private\n *\n */\n\nSocket.prototype.filterUpgrades = function (upgrades) {\n  var filteredUpgrades = [];\n  for (var i = 0, j = upgrades.length; i<j; i++) {\n    if (~index(this.transports, upgrades[i])) filteredUpgrades.push(upgrades[i]);\n  }\n  return filteredUpgrades;\n};\n","/**\n * Module dependencies.\n */\n\nvar parser = require('engine.io-parser');\nvar Emitter = require('component-emitter');\n\n/**\n * Module exports.\n */\n\nmodule.exports = Transport;\n\n/**\n * Transport abstract constructor.\n *\n * @param {Object} options.\n * @api private\n */\n\nfunction Transport (opts) {\n  this.path = opts.path;\n  this.hostname = opts.hostname;\n  this.port = opts.port;\n  this.secure = opts.secure;\n  this.query = opts.query;\n  this.timestampParam = opts.timestampParam;\n  this.timestampRequests = opts.timestampRequests;\n  this.readyState = '';\n  this.agent = opts.agent || false;\n  this.socket = opts.socket;\n  this.enablesXDR = opts.enablesXDR;\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx;\n  this.key = opts.key;\n  this.passphrase = opts.passphrase;\n  this.cert = opts.cert;\n  this.ca = opts.ca;\n  this.ciphers = opts.ciphers;\n  this.rejectUnauthorized = opts.rejectUnauthorized;\n\n  // other options for Node.js client\n  this.extraHeaders = opts.extraHeaders;\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Transport.prototype);\n\n/**\n * Emits an error.\n *\n * @param {String} str\n * @return {Transport} for chaining\n * @api public\n */\n\nTransport.prototype.onError = function (msg, desc) {\n  var err = new Error(msg);\n  err.type = 'TransportError';\n  err.description = desc;\n  this.emit('error', err);\n  return this;\n};\n\n/**\n * Opens the transport.\n *\n * @api public\n */\n\nTransport.prototype.open = function () {\n  if ('closed' == this.readyState || '' == this.readyState) {\n    this.readyState = 'opening';\n    this.doOpen();\n  }\n\n  return this;\n};\n\n/**\n * Closes the transport.\n *\n * @api private\n */\n\nTransport.prototype.close = function () {\n  if ('opening' == this.readyState || 'open' == this.readyState) {\n    this.doClose();\n    this.onClose();\n  }\n\n  return this;\n};\n\n/**\n * Sends multiple packets.\n *\n * @param {Array} packets\n * @api private\n */\n\nTransport.prototype.send = function(packets){\n  if ('open' == this.readyState) {\n    this.write(packets);\n  } else {\n    throw new Error('Transport not open');\n  }\n};\n\n/**\n * Called upon open\n *\n * @api private\n */\n\nTransport.prototype.onOpen = function () {\n  this.readyState = 'open';\n  this.writable = true;\n  this.emit('open');\n};\n\n/**\n * Called with data.\n *\n * @param {String} data\n * @api private\n */\n\nTransport.prototype.onData = function(data){\n  var packet = parser.decodePacket(data, this.socket.binaryType);\n  this.onPacket(packet);\n};\n\n/**\n * Called with a decoded packet.\n */\n\nTransport.prototype.onPacket = function (packet) {\n  this.emit('packet', packet);\n};\n\n/**\n * Called upon close.\n *\n * @api private\n */\n\nTransport.prototype.onClose = function () {\n  this.readyState = 'closed';\n  this.emit('close');\n};\n","/**\n * Module dependencies\n */\n\nvar XMLHttpRequest = require('xmlhttprequest-ssl');\nvar XHR = require('./polling-xhr');\nvar JSONP = require('./polling-jsonp');\nvar websocket = require('./websocket');\n\n/**\n * Export transports.\n */\n\nexports.polling = polling;\nexports.websocket = websocket;\n\n/**\n * Polling transport polymorphic constructor.\n * Decides on xhr vs jsonp based on feature detection.\n *\n * @api private\n */\n\nfunction polling(opts){\n  var xhr;\n  var xd = false;\n  var xs = false;\n  var jsonp = false !== opts.jsonp;\n\n  if (global.location) {\n    var isSSL = 'https:' == location.protocol;\n    var port = location.port;\n\n    // some user agents have empty `location.port`\n    if (!port) {\n      port = isSSL ? 443 : 80;\n    }\n\n    xd = opts.hostname != location.hostname || port != opts.port;\n    xs = opts.secure != isSSL;\n  }\n\n  opts.xdomain = xd;\n  opts.xscheme = xs;\n  xhr = new XMLHttpRequest(opts);\n\n  if ('open' in xhr && !opts.forceJSONP) {\n    return new XHR(opts);\n  } else {\n    if (!jsonp) throw new Error('JSONP disabled');\n    return new JSONP(opts);\n  }\n}\n","\n/**\n * Module requirements.\n */\n\nvar Polling = require('./polling');\nvar inherit = require('component-inherit');\n\n/**\n * Module exports.\n */\n\nmodule.exports = JSONPPolling;\n\n/**\n * Cached regular expressions.\n */\n\nvar rNewline = /\\n/g;\nvar rEscapedNewline = /\\\\n/g;\n\n/**\n * Global JSONP callbacks.\n */\n\nvar callbacks;\n\n/**\n * Callbacks count.\n */\n\nvar index = 0;\n\n/**\n * Noop.\n */\n\nfunction empty () { }\n\n/**\n * JSONP Polling constructor.\n *\n * @param {Object} opts.\n * @api public\n */\n\nfunction JSONPPolling (opts) {\n  Polling.call(this, opts);\n\n  this.query = this.query || {};\n\n  // define global callbacks array if not present\n  // we do this here (lazily) to avoid unneeded global pollution\n  if (!callbacks) {\n    // we need to consider multiple engines in the same page\n    if (!global.___eio) global.___eio = [];\n    callbacks = global.___eio;\n  }\n\n  // callback identifier\n  this.index = callbacks.length;\n\n  // add callback to jsonp global\n  var self = this;\n  callbacks.push(function (msg) {\n    self.onData(msg);\n  });\n\n  // append to query string\n  this.query.j = this.index;\n\n  // prevent spurious errors from being emitted when the window is unloaded\n  if (global.document && global.addEventListener) {\n    global.addEventListener('beforeunload', function () {\n      if (self.script) self.script.onerror = empty;\n    }, false);\n  }\n}\n\n/**\n * Inherits from Polling.\n */\n\ninherit(JSONPPolling, Polling);\n\n/*\n * JSONP only supports binary as base64 encoded strings\n */\n\nJSONPPolling.prototype.supportsBinary = false;\n\n/**\n * Closes the socket.\n *\n * @api private\n */\n\nJSONPPolling.prototype.doClose = function () {\n  if (this.script) {\n    this.script.parentNode.removeChild(this.script);\n    this.script = null;\n  }\n\n  if (this.form) {\n    this.form.parentNode.removeChild(this.form);\n    this.form = null;\n    this.iframe = null;\n  }\n\n  Polling.prototype.doClose.call(this);\n};\n\n/**\n * Starts a poll cycle.\n *\n * @api private\n */\n\nJSONPPolling.prototype.doPoll = function () {\n  var self = this;\n  var script = document.createElement('script');\n\n  if (this.script) {\n    this.script.parentNode.removeChild(this.script);\n    this.script = null;\n  }\n\n  script.async = true;\n  script.src = this.uri();\n  script.onerror = function(e){\n    self.onError('jsonp poll error',e);\n  };\n\n  var insertAt = document.getElementsByTagName('script')[0];\n  if (insertAt) {\n    insertAt.parentNode.insertBefore(script, insertAt);\n  }\n  else {\n    (document.head || document.body).appendChild(script);\n  }\n  this.script = script;\n\n  var isUAgecko = 'undefined' != typeof navigator && /gecko/i.test(navigator.userAgent);\n  \n  if (isUAgecko) {\n    setTimeout(function () {\n      var iframe = document.createElement('iframe');\n      document.body.appendChild(iframe);\n      document.body.removeChild(iframe);\n    }, 100);\n  }\n};\n\n/**\n * Writes with a hidden iframe.\n *\n * @param {String} data to send\n * @param {Function} called upon flush.\n * @api private\n */\n\nJSONPPolling.prototype.doWrite = function (data, fn) {\n  var self = this;\n\n  if (!this.form) {\n    var form = document.createElement('form');\n    var area = document.createElement('textarea');\n    var id = this.iframeId = 'eio_iframe_' + this.index;\n    var iframe;\n\n    form.className = 'socketio';\n    form.style.position = 'absolute';\n    form.style.top = '-1000px';\n    form.style.left = '-1000px';\n    form.target = id;\n    form.method = 'POST';\n    form.setAttribute('accept-charset', 'utf-8');\n    area.name = 'd';\n    form.appendChild(area);\n    document.body.appendChild(form);\n\n    this.form = form;\n    this.area = area;\n  }\n\n  this.form.action = this.uri();\n\n  function complete () {\n    initIframe();\n    fn();\n  }\n\n  function initIframe () {\n    if (self.iframe) {\n      try {\n        self.form.removeChild(self.iframe);\n      } catch (e) {\n        self.onError('jsonp polling iframe removal error', e);\n      }\n    }\n\n    try {\n      // ie6 dynamic iframes with target=\"\" support (thanks Chris Lambacher)\n      var html = '<iframe src=\"javascript:0\" name=\"'+ self.iframeId +'\">';\n      iframe = document.createElement(html);\n    } catch (e) {\n      iframe = document.createElement('iframe');\n      iframe.name = self.iframeId;\n      iframe.src = 'javascript:0';\n    }\n\n    iframe.id = self.iframeId;\n\n    self.form.appendChild(iframe);\n    self.iframe = iframe;\n  }\n\n  initIframe();\n\n  // escape \\n to prevent it from being converted into \\r\\n by some UAs\n  // double escaping is required for escaped new lines because unescaping of new lines can be done safely on server-side\n  data = data.replace(rEscapedNewline, '\\\\\\n');\n  this.area.value = data.replace(rNewline, '\\\\n');\n\n  try {\n    this.form.submit();\n  } catch(e) {}\n\n  if (this.iframe.attachEvent) {\n    this.iframe.onreadystatechange = function(){\n      if (self.iframe.readyState == 'complete') {\n        complete();\n      }\n    };\n  } else {\n    this.iframe.onload = complete;\n  }\n};\n","/**\n * Module requirements.\n */\n\nvar XMLHttpRequest = require('xmlhttprequest-ssl');\nvar Polling = require('./polling');\nvar Emitter = require('component-emitter');\nvar inherit = require('component-inherit');\nvar debug = require('debug')('engine.io-client:polling-xhr');\n\n/**\n * Module exports.\n */\n\nmodule.exports = XHR;\nmodule.exports.Request = Request;\n\n/**\n * Empty function\n */\n\nfunction empty(){}\n\n/**\n * XHR Polling constructor.\n *\n * @param {Object} opts\n * @api public\n */\n\nfunction XHR(opts){\n  Polling.call(this, opts);\n\n  if (global.location) {\n    var isSSL = 'https:' == location.protocol;\n    var port = location.port;\n\n    // some user agents have empty `location.port`\n    if (!port) {\n      port = isSSL ? 443 : 80;\n    }\n\n    this.xd = opts.hostname != global.location.hostname ||\n      port != opts.port;\n    this.xs = opts.secure != isSSL;\n  } else {\n    this.extraHeaders = opts.extraHeaders;\n  }\n}\n\n/**\n * Inherits from Polling.\n */\n\ninherit(XHR, Polling);\n\n/**\n * XHR supports binary\n */\n\nXHR.prototype.supportsBinary = true;\n\n/**\n * Creates a request.\n *\n * @param {String} method\n * @api private\n */\n\nXHR.prototype.request = function(opts){\n  opts = opts || {};\n  opts.uri = this.uri();\n  opts.xd = this.xd;\n  opts.xs = this.xs;\n  opts.agent = this.agent || false;\n  opts.supportsBinary = this.supportsBinary;\n  opts.enablesXDR = this.enablesXDR;\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n\n  // other options for Node.js client\n  opts.extraHeaders = this.extraHeaders;\n\n  return new Request(opts);\n};\n\n/**\n * Sends data.\n *\n * @param {String} data to send.\n * @param {Function} called upon flush.\n * @api private\n */\n\nXHR.prototype.doWrite = function(data, fn){\n  var isBinary = typeof data !== 'string' && data !== undefined;\n  var req = this.request({ method: 'POST', data: data, isBinary: isBinary });\n  var self = this;\n  req.on('success', fn);\n  req.on('error', function(err){\n    self.onError('xhr post error', err);\n  });\n  this.sendXhr = req;\n};\n\n/**\n * Starts a poll cycle.\n *\n * @api private\n */\n\nXHR.prototype.doPoll = function(){\n  debug('xhr poll');\n  var req = this.request();\n  var self = this;\n  req.on('data', function(data){\n    self.onData(data);\n  });\n  req.on('error', function(err){\n    self.onError('xhr poll error', err);\n  });\n  this.pollXhr = req;\n};\n\n/**\n * Request constructor\n *\n * @param {Object} options\n * @api public\n */\n\nfunction Request(opts){\n  this.method = opts.method || 'GET';\n  this.uri = opts.uri;\n  this.xd = !!opts.xd;\n  this.xs = !!opts.xs;\n  this.async = false !== opts.async;\n  this.data = undefined != opts.data ? opts.data : null;\n  this.agent = opts.agent;\n  this.isBinary = opts.isBinary;\n  this.supportsBinary = opts.supportsBinary;\n  this.enablesXDR = opts.enablesXDR;\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx;\n  this.key = opts.key;\n  this.passphrase = opts.passphrase;\n  this.cert = opts.cert;\n  this.ca = opts.ca;\n  this.ciphers = opts.ciphers;\n  this.rejectUnauthorized = opts.rejectUnauthorized;\n\n  // other options for Node.js client\n  this.extraHeaders = opts.extraHeaders;\n\n  this.create();\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Request.prototype);\n\n/**\n * Creates the XHR object and sends the request.\n *\n * @api private\n */\n\nRequest.prototype.create = function(){\n  var opts = { agent: this.agent, xdomain: this.xd, xscheme: this.xs, enablesXDR: this.enablesXDR };\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n\n  var xhr = this.xhr = new XMLHttpRequest(opts);\n  var self = this;\n\n  try {\n    debug('xhr open %s: %s', this.method, this.uri);\n    xhr.open(this.method, this.uri, this.async);\n    try {\n      if (this.extraHeaders) {\n        xhr.setDisableHeaderCheck(true);\n        for (var i in this.extraHeaders) {\n          if (this.extraHeaders.hasOwnProperty(i)) {\n            xhr.setRequestHeader(i, this.extraHeaders[i]);\n          }\n        }\n      }\n    } catch (e) {}\n    if (this.supportsBinary) {\n      // This has to be done after open because Firefox is stupid\n      // http://stackoverflow.com/questions/13216903/get-binary-data-with-xmlhttprequest-in-a-firefox-extension\n      xhr.responseType = 'arraybuffer';\n    }\n\n    if ('POST' == this.method) {\n      try {\n        if (this.isBinary) {\n          xhr.setRequestHeader('Content-type', 'application/octet-stream');\n        } else {\n          xhr.setRequestHeader('Content-type', 'text/plain;charset=UTF-8');\n        }\n      } catch (e) {}\n    }\n\n    // ie6 check\n    if ('withCredentials' in xhr) {\n      xhr.withCredentials = true;\n    }\n\n    if (this.hasXDR()) {\n      xhr.onload = function(){\n        self.onLoad();\n      };\n      xhr.onerror = function(){\n        self.onError(xhr.responseText);\n      };\n    } else {\n      xhr.onreadystatechange = function(){\n        if (4 != xhr.readyState) return;\n        if (200 == xhr.status || 1223 == xhr.status) {\n          self.onLoad();\n        } else {\n          // make sure the `error` event handler that's user-set\n          // does not throw in the same tick and gets caught here\n          setTimeout(function(){\n            self.onError(xhr.status);\n          }, 0);\n        }\n      };\n    }\n\n    debug('xhr data %s', this.data);\n    xhr.send(this.data);\n  } catch (e) {\n    // Need to defer since .create() is called directly fhrom the constructor\n    // and thus the 'error' event can only be only bound *after* this exception\n    // occurs.  Therefore, also, we cannot throw here at all.\n    setTimeout(function() {\n      self.onError(e);\n    }, 0);\n    return;\n  }\n\n  if (global.document) {\n    this.index = Request.requestsCount++;\n    Request.requests[this.index] = this;\n  }\n};\n\n/**\n * Called upon successful response.\n *\n * @api private\n */\n\nRequest.prototype.onSuccess = function(){\n  this.emit('success');\n  this.cleanup();\n};\n\n/**\n * Called if we have data.\n *\n * @api private\n */\n\nRequest.prototype.onData = function(data){\n  this.emit('data', data);\n  this.onSuccess();\n};\n\n/**\n * Called upon error.\n *\n * @api private\n */\n\nRequest.prototype.onError = function(err){\n  this.emit('error', err);\n  this.cleanup(true);\n};\n\n/**\n * Cleans up house.\n *\n * @api private\n */\n\nRequest.prototype.cleanup = function(fromError){\n  if ('undefined' == typeof this.xhr || null === this.xhr) {\n    return;\n  }\n  // xmlhttprequest\n  if (this.hasXDR()) {\n    this.xhr.onload = this.xhr.onerror = empty;\n  } else {\n    this.xhr.onreadystatechange = empty;\n  }\n\n  if (fromError) {\n    try {\n      this.xhr.abort();\n    } catch(e) {}\n  }\n\n  if (global.document) {\n    delete Request.requests[this.index];\n  }\n\n  this.xhr = null;\n};\n\n/**\n * Called upon load.\n *\n * @api private\n */\n\nRequest.prototype.onLoad = function(){\n  var data;\n  try {\n    var contentType;\n    try {\n      contentType = this.xhr.getResponseHeader('Content-Type').split(';')[0];\n    } catch (e) {}\n    if (contentType === 'application/octet-stream') {\n      data = this.xhr.response;\n    } else {\n      if (!this.supportsBinary) {\n        data = this.xhr.responseText;\n      } else {\n        try {\n          data = String.fromCharCode.apply(null, new Uint8Array(this.xhr.response));\n        } catch (e) {\n          var ui8Arr = new Uint8Array(this.xhr.response);\n          var dataArray = [];\n          for (var idx = 0, length = ui8Arr.length; idx < length; idx++) {\n            dataArray.push(ui8Arr[idx]);\n          }\n\n          data = String.fromCharCode.apply(null, dataArray);\n        }\n      }\n    }\n  } catch (e) {\n    this.onError(e);\n  }\n  if (null != data) {\n    this.onData(data);\n  }\n};\n\n/**\n * Check if it has XDomainRequest.\n *\n * @api private\n */\n\nRequest.prototype.hasXDR = function(){\n  return 'undefined' !== typeof global.XDomainRequest && !this.xs && this.enablesXDR;\n};\n\n/**\n * Aborts the request.\n *\n * @api public\n */\n\nRequest.prototype.abort = function(){\n  this.cleanup();\n};\n\n/**\n * Aborts pending requests when unloading the window. This is needed to prevent\n * memory leaks (e.g. when using IE) and to ensure that no spurious error is\n * emitted.\n */\n\nif (global.document) {\n  Request.requestsCount = 0;\n  Request.requests = {};\n  if (global.attachEvent) {\n    global.attachEvent('onunload', unloadHandler);\n  } else if (global.addEventListener) {\n    global.addEventListener('beforeunload', unloadHandler, false);\n  }\n}\n\nfunction unloadHandler() {\n  for (var i in Request.requests) {\n    if (Request.requests.hasOwnProperty(i)) {\n      Request.requests[i].abort();\n    }\n  }\n}\n","/**\n * Module dependencies.\n */\n\nvar Transport = require('../transport');\nvar parseqs = require('parseqs');\nvar parser = require('engine.io-parser');\nvar inherit = require('component-inherit');\nvar yeast = require('yeast');\nvar debug = require('debug')('engine.io-client:polling');\n\n/**\n * Module exports.\n */\n\nmodule.exports = Polling;\n\n/**\n * Is XHR2 supported?\n */\n\nvar hasXHR2 = (function() {\n  var XMLHttpRequest = require('xmlhttprequest-ssl');\n  var xhr = new XMLHttpRequest({ xdomain: false });\n  return null != xhr.responseType;\n})();\n\n/**\n * Polling interface.\n *\n * @param {Object} opts\n * @api private\n */\n\nfunction Polling(opts){\n  var forceBase64 = (opts && opts.forceBase64);\n  if (!hasXHR2 || forceBase64) {\n    this.supportsBinary = false;\n  }\n  Transport.call(this, opts);\n}\n\n/**\n * Inherits from Transport.\n */\n\ninherit(Polling, Transport);\n\n/**\n * Transport name.\n */\n\nPolling.prototype.name = 'polling';\n\n/**\n * Opens the socket (triggers polling). We write a PING message to determine\n * when the transport is open.\n *\n * @api private\n */\n\nPolling.prototype.doOpen = function(){\n  this.poll();\n};\n\n/**\n * Pauses polling.\n *\n * @param {Function} callback upon buffers are flushed and transport is paused\n * @api private\n */\n\nPolling.prototype.pause = function(onPause){\n  var pending = 0;\n  var self = this;\n\n  this.readyState = 'pausing';\n\n  function pause(){\n    debug('paused');\n    self.readyState = 'paused';\n    onPause();\n  }\n\n  if (this.polling || !this.writable) {\n    var total = 0;\n\n    if (this.polling) {\n      debug('we are currently polling - waiting to pause');\n      total++;\n      this.once('pollComplete', function(){\n        debug('pre-pause polling complete');\n        --total || pause();\n      });\n    }\n\n    if (!this.writable) {\n      debug('we are currently writing - waiting to pause');\n      total++;\n      this.once('drain', function(){\n        debug('pre-pause writing complete');\n        --total || pause();\n      });\n    }\n  } else {\n    pause();\n  }\n};\n\n/**\n * Starts polling cycle.\n *\n * @api public\n */\n\nPolling.prototype.poll = function(){\n  debug('polling');\n  this.polling = true;\n  this.doPoll();\n  this.emit('poll');\n};\n\n/**\n * Overloads onData to detect payloads.\n *\n * @api private\n */\n\nPolling.prototype.onData = function(data){\n  var self = this;\n  debug('polling got data %s', data);\n  var callback = function(packet, index, total) {\n    // if its the first message we consider the transport open\n    if ('opening' == self.readyState) {\n      self.onOpen();\n    }\n\n    // if its a close packet, we close the ongoing requests\n    if ('close' == packet.type) {\n      self.onClose();\n      return false;\n    }\n\n    // otherwise bypass onData and handle the message\n    self.onPacket(packet);\n  };\n\n  // decode payload\n  parser.decodePayload(data, this.socket.binaryType, callback);\n\n  // if an event did not trigger closing\n  if ('closed' != this.readyState) {\n    // if we got data we're not polling\n    this.polling = false;\n    this.emit('pollComplete');\n\n    if ('open' == this.readyState) {\n      this.poll();\n    } else {\n      debug('ignoring poll - transport state \"%s\"', this.readyState);\n    }\n  }\n};\n\n/**\n * For polling, send a close packet.\n *\n * @api private\n */\n\nPolling.prototype.doClose = function(){\n  var self = this;\n\n  function close(){\n    debug('writing close packet');\n    self.write([{ type: 'close' }]);\n  }\n\n  if ('open' == this.readyState) {\n    debug('transport open - closing');\n    close();\n  } else {\n    // in case we're trying to close while\n    // handshaking is in progress (GH-164)\n    debug('transport not open - deferring close');\n    this.once('open', close);\n  }\n};\n\n/**\n * Writes a packets payload.\n *\n * @param {Array} data packets\n * @param {Function} drain callback\n * @api private\n */\n\nPolling.prototype.write = function(packets){\n  var self = this;\n  this.writable = false;\n  var callbackfn = function() {\n    self.writable = true;\n    self.emit('drain');\n  };\n\n  var self = this;\n  parser.encodePayload(packets, this.supportsBinary, function(data) {\n    self.doWrite(data, callbackfn);\n  });\n};\n\n/**\n * Generates uri for connection.\n *\n * @api private\n */\n\nPolling.prototype.uri = function(){\n  var query = this.query || {};\n  var schema = this.secure ? 'https' : 'http';\n  var port = '';\n\n  // cache busting is forced\n  if (false !== this.timestampRequests) {\n    query[this.timestampParam] = yeast();\n  }\n\n  if (!this.supportsBinary && !query.sid) {\n    query.b64 = 1;\n  }\n\n  query = parseqs.encode(query);\n\n  // avoid port if default for schema\n  if (this.port && (('https' == schema && this.port != 443) ||\n     ('http' == schema && this.port != 80))) {\n    port = ':' + this.port;\n  }\n\n  // prepend ? to query\n  if (query.length) {\n    query = '?' + query;\n  }\n\n  var ipv6 = this.hostname.indexOf(':') !== -1;\n  return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;\n};\n","/**\n * Module dependencies.\n */\n\nvar Transport = require('../transport');\nvar parser = require('engine.io-parser');\nvar parseqs = require('parseqs');\nvar inherit = require('component-inherit');\nvar yeast = require('yeast');\nvar debug = require('debug')('engine.io-client:websocket');\nvar BrowserWebSocket = global.WebSocket || global.MozWebSocket;\n\n/**\n * Get either the `WebSocket` or `MozWebSocket` globals\n * in the browser or try to resolve WebSocket-compatible\n * interface exposed by `ws` for Node-like environment.\n */\n\nvar WebSocket = BrowserWebSocket;\nif (!WebSocket && typeof window === 'undefined') {\n  try {\n    WebSocket = require('ws');\n  } catch (e) { }\n}\n\n/**\n * Module exports.\n */\n\nmodule.exports = WS;\n\n/**\n * WebSocket transport constructor.\n *\n * @api {Object} connection options\n * @api public\n */\n\nfunction WS(opts){\n  var forceBase64 = (opts && opts.forceBase64);\n  if (forceBase64) {\n    this.supportsBinary = false;\n  }\n  this.perMessageDeflate = opts.perMessageDeflate;\n  Transport.call(this, opts);\n}\n\n/**\n * Inherits from Transport.\n */\n\ninherit(WS, Transport);\n\n/**\n * Transport name.\n *\n * @api public\n */\n\nWS.prototype.name = 'websocket';\n\n/*\n * WebSockets support binary\n */\n\nWS.prototype.supportsBinary = true;\n\n/**\n * Opens socket.\n *\n * @api private\n */\n\nWS.prototype.doOpen = function(){\n  if (!this.check()) {\n    // let probe timeout\n    return;\n  }\n\n  var self = this;\n  var uri = this.uri();\n  var protocols = void(0);\n  var opts = {\n    agent: this.agent,\n    perMessageDeflate: this.perMessageDeflate\n  };\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n  if (this.extraHeaders) {\n    opts.headers = this.extraHeaders;\n  }\n\n  this.ws = BrowserWebSocket ? new WebSocket(uri) : new WebSocket(uri, protocols, opts);\n\n  if (this.ws.binaryType === undefined) {\n    this.supportsBinary = false;\n  }\n\n  if (this.ws.supports && this.ws.supports.binary) {\n    this.supportsBinary = true;\n    this.ws.binaryType = 'buffer';\n  } else {\n    this.ws.binaryType = 'arraybuffer';\n  }\n\n  this.addEventListeners();\n};\n\n/**\n * Adds event listeners to the socket\n *\n * @api private\n */\n\nWS.prototype.addEventListeners = function(){\n  var self = this;\n\n  this.ws.onopen = function(){\n    self.onOpen();\n  };\n  this.ws.onclose = function(){\n    self.onClose();\n  };\n  this.ws.onmessage = function(ev){\n    self.onData(ev.data);\n  };\n  this.ws.onerror = function(e){\n    self.onError('websocket error', e);\n  };\n};\n\n/**\n * Override `onData` to use a timer on iOS.\n * See: https://gist.github.com/mloughran/2052006\n *\n * @api private\n */\n\nif ('undefined' != typeof navigator\n  && /iPad|iPhone|iPod/i.test(navigator.userAgent)) {\n  WS.prototype.onData = function(data){\n    var self = this;\n    setTimeout(function(){\n      Transport.prototype.onData.call(self, data);\n    }, 0);\n  };\n}\n\n/**\n * Writes data to socket.\n *\n * @param {Array} array of packets.\n * @api private\n */\n\nWS.prototype.write = function(packets){\n  var self = this;\n  this.writable = false;\n\n  // encodePacket efficient as it uses WS framing\n  // no need for encodePayload\n  var total = packets.length;\n  for (var i = 0, l = total; i < l; i++) {\n    (function(packet) {\n      parser.encodePacket(packet, self.supportsBinary, function(data) {\n        if (!BrowserWebSocket) {\n          // always create a new object (GH-437)\n          var opts = {};\n          if (packet.options) {\n            opts.compress = packet.options.compress;\n          }\n\n          if (self.perMessageDeflate) {\n            var len = 'string' == typeof data ? global.Buffer.byteLength(data) : data.length;\n            if (len < self.perMessageDeflate.threshold) {\n              opts.compress = false;\n            }\n          }\n        }\n\n        //Sometimes the websocket has already been closed but the browser didn't\n        //have a chance of informing us about it yet, in that case send will\n        //throw an error\n        try {\n          if (BrowserWebSocket) {\n            // TypeError is thrown when passing the second argument on Safari\n            self.ws.send(data);\n          } else {\n            self.ws.send(data, opts);\n          }\n        } catch (e){\n          debug('websocket closed before onclose event');\n        }\n\n        --total || done();\n      });\n    })(packets[i]);\n  }\n\n  function done(){\n    self.emit('flush');\n\n    // fake drain\n    // defer to next tick to allow Socket to clear writeBuffer\n    setTimeout(function(){\n      self.writable = true;\n      self.emit('drain');\n    }, 0);\n  }\n};\n\n/**\n * Called upon close\n *\n * @api private\n */\n\nWS.prototype.onClose = function(){\n  Transport.prototype.onClose.call(this);\n};\n\n/**\n * Closes socket.\n *\n * @api private\n */\n\nWS.prototype.doClose = function(){\n  if (typeof this.ws !== 'undefined') {\n    this.ws.close();\n  }\n};\n\n/**\n * Generates uri for connection.\n *\n * @api private\n */\n\nWS.prototype.uri = function(){\n  var query = this.query || {};\n  var schema = this.secure ? 'wss' : 'ws';\n  var port = '';\n\n  // avoid port if default for schema\n  if (this.port && (('wss' == schema && this.port != 443)\n    || ('ws' == schema && this.port != 80))) {\n    port = ':' + this.port;\n  }\n\n  // append timestamp to URI\n  if (this.timestampRequests) {\n    query[this.timestampParam] = yeast();\n  }\n\n  // communicate binary support capabilities\n  if (!this.supportsBinary) {\n    query.b64 = 1;\n  }\n\n  query = parseqs.encode(query);\n\n  // prepend ? to query\n  if (query.length) {\n    query = '?' + query;\n  }\n\n  var ipv6 = this.hostname.indexOf(':') !== -1;\n  return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;\n};\n\n/**\n * Feature detection for WebSocket.\n *\n * @return {Boolean} whether this transport is available.\n * @api public\n */\n\nWS.prototype.check = function(){\n  return !!WebSocket && !('__initialize' in WebSocket && this.name === WS.prototype.name);\n};\n","// browser shim for xmlhttprequest module\nvar hasCORS = require('has-cors');\n\nmodule.exports = function(opts) {\n  var xdomain = opts.xdomain;\n\n  // scheme must be same when usign XDomainRequest\n  // http://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx\n  var xscheme = opts.xscheme;\n\n  // XDomainRequest has a flow of not sending cookie, therefore it should be disabled as a default.\n  // https://github.com/Automattic/engine.io-client/pull/217\n  var enablesXDR = opts.enablesXDR;\n\n  // XMLHttpRequest can be disabled on IE\n  try {\n    if ('undefined' != typeof XMLHttpRequest && (!xdomain || hasCORS)) {\n      return new XMLHttpRequest();\n    }\n  } catch (e) { }\n\n  // Use XDomainRequest for IE8 if enablesXDR is true\n  // because loading bar keeps flashing when using jsonp-polling\n  // https://github.com/yujiosaka/socke.io-ie8-loading-example\n  try {\n    if ('undefined' != typeof XDomainRequest && !xscheme && enablesXDR) {\n      return new XDomainRequest();\n    }\n  } catch (e) { }\n\n  if (!xdomain) {\n    try {\n      return new ActiveXObject('Microsoft.XMLHTTP');\n    } catch(e) { }\n  }\n}\n","/**\n * Module dependencies.\n */\n\nvar keys = require('./keys');\nvar hasBinary = require('has-binary');\nvar sliceBuffer = require('arraybuffer.slice');\nvar base64encoder = require('base64-arraybuffer');\nvar after = require('after');\nvar utf8 = require('utf8');\n\n/**\n * Check if we are running an android browser. That requires us to use\n * ArrayBuffer with polling transports...\n *\n * http://ghinda.net/jpeg-blob-ajax-android/\n */\n\nvar isAndroid = navigator.userAgent.match(/Android/i);\n\n/**\n * Check if we are running in PhantomJS.\n * Uploading a Blob with PhantomJS does not work correctly, as reported here:\n * https://github.com/ariya/phantomjs/issues/11395\n * @type boolean\n */\nvar isPhantomJS = /PhantomJS/i.test(navigator.userAgent);\n\n/**\n * When true, avoids using Blobs to encode payloads.\n * @type boolean\n */\nvar dontSendBlobs = isAndroid || isPhantomJS;\n\n/**\n * Current protocol version.\n */\n\nexports.protocol = 3;\n\n/**\n * Packet types.\n */\n\nvar packets = exports.packets = {\n    open:     0    // non-ws\n  , close:    1    // non-ws\n  , ping:     2\n  , pong:     3\n  , message:  4\n  , upgrade:  5\n  , noop:     6\n};\n\nvar packetslist = keys(packets);\n\n/**\n * Premade error packet.\n */\n\nvar err = { type: 'error', data: 'parser error' };\n\n/**\n * Create a blob api even for blob builder when vendor prefixes exist\n */\n\nvar Blob = require('blob');\n\n/**\n * Encodes a packet.\n *\n *     <packet type id> [ <data> ]\n *\n * Example:\n *\n *     5hello world\n *     3\n *     4\n *\n * Binary is encoded in an identical principle\n *\n * @api private\n */\n\nexports.encodePacket = function (packet, supportsBinary, utf8encode, callback) {\n  if ('function' == typeof supportsBinary) {\n    callback = supportsBinary;\n    supportsBinary = false;\n  }\n\n  if ('function' == typeof utf8encode) {\n    callback = utf8encode;\n    utf8encode = null;\n  }\n\n  var data = (packet.data === undefined)\n    ? undefined\n    : packet.data.buffer || packet.data;\n\n  if (global.ArrayBuffer && data instanceof ArrayBuffer) {\n    return encodeArrayBuffer(packet, supportsBinary, callback);\n  } else if (Blob && data instanceof global.Blob) {\n    return encodeBlob(packet, supportsBinary, callback);\n  }\n\n  // might be an object with { base64: true, data: dataAsBase64String }\n  if (data && data.base64) {\n    return encodeBase64Object(packet, callback);\n  }\n\n  // Sending data as a utf-8 string\n  var encoded = packets[packet.type];\n\n  // data fragment is optional\n  if (undefined !== packet.data) {\n    encoded += utf8encode ? utf8.encode(String(packet.data)) : String(packet.data);\n  }\n\n  return callback('' + encoded);\n\n};\n\nfunction encodeBase64Object(packet, callback) {\n  // packet data is an object { base64: true, data: dataAsBase64String }\n  var message = 'b' + exports.packets[packet.type] + packet.data.data;\n  return callback(message);\n}\n\n/**\n * Encode packet helpers for binary types\n */\n\nfunction encodeArrayBuffer(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  var data = packet.data;\n  var contentArray = new Uint8Array(data);\n  var resultBuffer = new Uint8Array(1 + data.byteLength);\n\n  resultBuffer[0] = packets[packet.type];\n  for (var i = 0; i < contentArray.length; i++) {\n    resultBuffer[i+1] = contentArray[i];\n  }\n\n  return callback(resultBuffer.buffer);\n}\n\nfunction encodeBlobAsArrayBuffer(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  var fr = new FileReader();\n  fr.onload = function() {\n    packet.data = fr.result;\n    exports.encodePacket(packet, supportsBinary, true, callback);\n  };\n  return fr.readAsArrayBuffer(packet.data);\n}\n\nfunction encodeBlob(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  if (dontSendBlobs) {\n    return encodeBlobAsArrayBuffer(packet, supportsBinary, callback);\n  }\n\n  var length = new Uint8Array(1);\n  length[0] = packets[packet.type];\n  var blob = new Blob([length.buffer, packet.data]);\n\n  return callback(blob);\n}\n\n/**\n * Encodes a packet with binary data in a base64 string\n *\n * @param {Object} packet, has `type` and `data`\n * @return {String} base64 encoded message\n */\n\nexports.encodeBase64Packet = function(packet, callback) {\n  var message = 'b' + exports.packets[packet.type];\n  if (Blob && packet.data instanceof global.Blob) {\n    var fr = new FileReader();\n    fr.onload = function() {\n      var b64 = fr.result.split(',')[1];\n      callback(message + b64);\n    };\n    return fr.readAsDataURL(packet.data);\n  }\n\n  var b64data;\n  try {\n    b64data = String.fromCharCode.apply(null, new Uint8Array(packet.data));\n  } catch (e) {\n    // iPhone Safari doesn't let you apply with typed arrays\n    var typed = new Uint8Array(packet.data);\n    var basic = new Array(typed.length);\n    for (var i = 0; i < typed.length; i++) {\n      basic[i] = typed[i];\n    }\n    b64data = String.fromCharCode.apply(null, basic);\n  }\n  message += global.btoa(b64data);\n  return callback(message);\n};\n\n/**\n * Decodes a packet. Changes format to Blob if requested.\n *\n * @return {Object} with `type` and `data` (if any)\n * @api private\n */\n\nexports.decodePacket = function (data, binaryType, utf8decode) {\n  // String data\n  if (typeof data == 'string' || data === undefined) {\n    if (data.charAt(0) == 'b') {\n      return exports.decodeBase64Packet(data.substr(1), binaryType);\n    }\n\n    if (utf8decode) {\n      try {\n        data = utf8.decode(data);\n      } catch (e) {\n        return err;\n      }\n    }\n    var type = data.charAt(0);\n\n    if (Number(type) != type || !packetslist[type]) {\n      return err;\n    }\n\n    if (data.length > 1) {\n      return { type: packetslist[type], data: data.substring(1) };\n    } else {\n      return { type: packetslist[type] };\n    }\n  }\n\n  var asArray = new Uint8Array(data);\n  var type = asArray[0];\n  var rest = sliceBuffer(data, 1);\n  if (Blob && binaryType === 'blob') {\n    rest = new Blob([rest]);\n  }\n  return { type: packetslist[type], data: rest };\n};\n\n/**\n * Decodes a packet encoded in a base64 string\n *\n * @param {String} base64 encoded message\n * @return {Object} with `type` and `data` (if any)\n */\n\nexports.decodeBase64Packet = function(msg, binaryType) {\n  var type = packetslist[msg.charAt(0)];\n  if (!global.ArrayBuffer) {\n    return { type: type, data: { base64: true, data: msg.substr(1) } };\n  }\n\n  var data = base64encoder.decode(msg.substr(1));\n\n  if (binaryType === 'blob' && Blob) {\n    data = new Blob([data]);\n  }\n\n  return { type: type, data: data };\n};\n\n/**\n * Encodes multiple messages (payload).\n *\n *     <length>:data\n *\n * Example:\n *\n *     11:hello world2:hi\n *\n * If any contents are binary, they will be encoded as base64 strings. Base64\n * encoded strings are marked with a b before the length specifier\n *\n * @param {Array} packets\n * @api private\n */\n\nexports.encodePayload = function (packets, supportsBinary, callback) {\n  if (typeof supportsBinary == 'function') {\n    callback = supportsBinary;\n    supportsBinary = null;\n  }\n\n  var isBinary = hasBinary(packets);\n\n  if (supportsBinary && isBinary) {\n    if (Blob && !dontSendBlobs) {\n      return exports.encodePayloadAsBlob(packets, callback);\n    }\n\n    return exports.encodePayloadAsArrayBuffer(packets, callback);\n  }\n\n  if (!packets.length) {\n    return callback('0:');\n  }\n\n  function setLengthHeader(message) {\n    return message.length + ':' + message;\n  }\n\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, !isBinary ? false : supportsBinary, true, function(message) {\n      doneCallback(null, setLengthHeader(message));\n    });\n  }\n\n  map(packets, encodeOne, function(err, results) {\n    return callback(results.join(''));\n  });\n};\n\n/**\n * Async array map using after\n */\n\nfunction map(ary, each, done) {\n  var result = new Array(ary.length);\n  var next = after(ary.length, done);\n\n  var eachWithIndex = function(i, el, cb) {\n    each(el, function(error, msg) {\n      result[i] = msg;\n      cb(error, result);\n    });\n  };\n\n  for (var i = 0; i < ary.length; i++) {\n    eachWithIndex(i, ary[i], next);\n  }\n}\n\n/*\n * Decodes data when a payload is maybe expected. Possible binary contents are\n * decoded from their base64 representation\n *\n * @param {String} data, callback method\n * @api public\n */\n\nexports.decodePayload = function (data, binaryType, callback) {\n  if (typeof data != 'string') {\n    return exports.decodePayloadAsBinary(data, binaryType, callback);\n  }\n\n  if (typeof binaryType === 'function') {\n    callback = binaryType;\n    binaryType = null;\n  }\n\n  var packet;\n  if (data == '') {\n    // parser error - ignoring payload\n    return callback(err, 0, 1);\n  }\n\n  var length = ''\n    , n, msg;\n\n  for (var i = 0, l = data.length; i < l; i++) {\n    var chr = data.charAt(i);\n\n    if (':' != chr) {\n      length += chr;\n    } else {\n      if ('' == length || (length != (n = Number(length)))) {\n        // parser error - ignoring payload\n        return callback(err, 0, 1);\n      }\n\n      msg = data.substr(i + 1, n);\n\n      if (length != msg.length) {\n        // parser error - ignoring payload\n        return callback(err, 0, 1);\n      }\n\n      if (msg.length) {\n        packet = exports.decodePacket(msg, binaryType, true);\n\n        if (err.type == packet.type && err.data == packet.data) {\n          // parser error in individual packet - ignoring payload\n          return callback(err, 0, 1);\n        }\n\n        var ret = callback(packet, i + n, l);\n        if (false === ret) return;\n      }\n\n      // advance cursor\n      i += n;\n      length = '';\n    }\n  }\n\n  if (length != '') {\n    // parser error - ignoring payload\n    return callback(err, 0, 1);\n  }\n\n};\n\n/**\n * Encodes multiple messages (payload) as binary.\n *\n * <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number\n * 255><data>\n *\n * Example:\n * 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers\n *\n * @param {Array} packets\n * @return {ArrayBuffer} encoded payload\n * @api private\n */\n\nexports.encodePayloadAsArrayBuffer = function(packets, callback) {\n  if (!packets.length) {\n    return callback(new ArrayBuffer(0));\n  }\n\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, true, true, function(data) {\n      return doneCallback(null, data);\n    });\n  }\n\n  map(packets, encodeOne, function(err, encodedPackets) {\n    var totalLength = encodedPackets.reduce(function(acc, p) {\n      var len;\n      if (typeof p === 'string'){\n        len = p.length;\n      } else {\n        len = p.byteLength;\n      }\n      return acc + len.toString().length + len + 2; // string/binary identifier + separator = 2\n    }, 0);\n\n    var resultArray = new Uint8Array(totalLength);\n\n    var bufferIndex = 0;\n    encodedPackets.forEach(function(p) {\n      var isString = typeof p === 'string';\n      var ab = p;\n      if (isString) {\n        var view = new Uint8Array(p.length);\n        for (var i = 0; i < p.length; i++) {\n          view[i] = p.charCodeAt(i);\n        }\n        ab = view.buffer;\n      }\n\n      if (isString) { // not true binary\n        resultArray[bufferIndex++] = 0;\n      } else { // true binary\n        resultArray[bufferIndex++] = 1;\n      }\n\n      var lenStr = ab.byteLength.toString();\n      for (var i = 0; i < lenStr.length; i++) {\n        resultArray[bufferIndex++] = parseInt(lenStr[i]);\n      }\n      resultArray[bufferIndex++] = 255;\n\n      var view = new Uint8Array(ab);\n      for (var i = 0; i < view.length; i++) {\n        resultArray[bufferIndex++] = view[i];\n      }\n    });\n\n    return callback(resultArray.buffer);\n  });\n};\n\n/**\n * Encode as Blob\n */\n\nexports.encodePayloadAsBlob = function(packets, callback) {\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, true, true, function(encoded) {\n      var binaryIdentifier = new Uint8Array(1);\n      binaryIdentifier[0] = 1;\n      if (typeof encoded === 'string') {\n        var view = new Uint8Array(encoded.length);\n        for (var i = 0; i < encoded.length; i++) {\n          view[i] = encoded.charCodeAt(i);\n        }\n        encoded = view.buffer;\n        binaryIdentifier[0] = 0;\n      }\n\n      var len = (encoded instanceof ArrayBuffer)\n        ? encoded.byteLength\n        : encoded.size;\n\n      var lenStr = len.toString();\n      var lengthAry = new Uint8Array(lenStr.length + 1);\n      for (var i = 0; i < lenStr.length; i++) {\n        lengthAry[i] = parseInt(lenStr[i]);\n      }\n      lengthAry[lenStr.length] = 255;\n\n      if (Blob) {\n        var blob = new Blob([binaryIdentifier.buffer, lengthAry.buffer, encoded]);\n        doneCallback(null, blob);\n      }\n    });\n  }\n\n  map(packets, encodeOne, function(err, results) {\n    return callback(new Blob(results));\n  });\n};\n\n/*\n * Decodes data when a payload is maybe expected. Strings are decoded by\n * interpreting each byte as a key code for entries marked to start with 0. See\n * description of encodePayloadAsBinary\n *\n * @param {ArrayBuffer} data, callback method\n * @api public\n */\n\nexports.decodePayloadAsBinary = function (data, binaryType, callback) {\n  if (typeof binaryType === 'function') {\n    callback = binaryType;\n    binaryType = null;\n  }\n\n  var bufferTail = data;\n  var buffers = [];\n\n  var numberTooLong = false;\n  while (bufferTail.byteLength > 0) {\n    var tailArray = new Uint8Array(bufferTail);\n    var isString = tailArray[0] === 0;\n    var msgLength = '';\n\n    for (var i = 1; ; i++) {\n      if (tailArray[i] == 255) break;\n\n      if (msgLength.length > 310) {\n        numberTooLong = true;\n        break;\n      }\n\n      msgLength += tailArray[i];\n    }\n\n    if(numberTooLong) return callback(err, 0, 1);\n\n    bufferTail = sliceBuffer(bufferTail, 2 + msgLength.length);\n    msgLength = parseInt(msgLength);\n\n    var msg = sliceBuffer(bufferTail, 0, msgLength);\n    if (isString) {\n      try {\n        msg = String.fromCharCode.apply(null, new Uint8Array(msg));\n      } catch (e) {\n        // iPhone Safari doesn't let you apply to typed arrays\n        var typed = new Uint8Array(msg);\n        msg = '';\n        for (var i = 0; i < typed.length; i++) {\n          msg += String.fromCharCode(typed[i]);\n        }\n      }\n    }\n\n    buffers.push(msg);\n    bufferTail = sliceBuffer(bufferTail, msgLength);\n  }\n\n  var total = buffers.length;\n  buffers.forEach(function(buffer, i) {\n    callback(exports.decodePacket(buffer, binaryType, true), i, total);\n  });\n};\n","\n/**\n * Gets the keys for an object.\n *\n * @return {Array} keys\n * @api private\n */\n\nmodule.exports = Object.keys || function keys (obj){\n  var arr = [];\n  var has = Object.prototype.hasOwnProperty;\n\n  for (var i in obj) {\n    if (has.call(obj, i)) {\n      arr.push(i);\n    }\n  }\n  return arr;\n};\n","\n/*\n * Module requirements.\n */\n\nvar isArray = require('isarray');\n\n/**\n * Module exports.\n */\n\nmodule.exports = hasBinary;\n\n/**\n * Checks for binary data.\n *\n * Right now only Buffer and ArrayBuffer are supported..\n *\n * @param {Object} anything\n * @api public\n */\n\nfunction hasBinary(data) {\n\n  function _hasBinary(obj) {\n    if (!obj) return false;\n\n    if ( (global.Buffer && global.Buffer.isBuffer(obj)) ||\n         (global.ArrayBuffer && obj instanceof ArrayBuffer) ||\n         (global.Blob && obj instanceof Blob) ||\n         (global.File && obj instanceof File)\n        ) {\n      return true;\n    }\n\n    if (isArray(obj)) {\n      for (var i = 0; i < obj.length; i++) {\n          if (_hasBinary(obj[i])) {\n              return true;\n          }\n      }\n    } else if (obj && 'object' == typeof obj) {\n      if (obj.toJSON) {\n        obj = obj.toJSON();\n      }\n\n      for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key) && _hasBinary(obj[key])) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  }\n\n  return _hasBinary(data);\n}\n","\n/*\n * Module requirements.\n */\n\nvar isArray = require('isarray');\n\n/**\n * Module exports.\n */\n\nmodule.exports = hasBinary;\n\n/**\n * Checks for binary data.\n *\n * Right now only Buffer and ArrayBuffer are supported..\n *\n * @param {Object} anything\n * @api public\n */\n\nfunction hasBinary(data) {\n\n  function _hasBinary(obj) {\n    if (!obj) return false;\n\n    if ( (global.Buffer && global.Buffer.isBuffer && global.Buffer.isBuffer(obj)) ||\n         (global.ArrayBuffer && obj instanceof ArrayBuffer) ||\n         (global.Blob && obj instanceof Blob) ||\n         (global.File && obj instanceof File)\n        ) {\n      return true;\n    }\n\n    if (isArray(obj)) {\n      for (var i = 0; i < obj.length; i++) {\n          if (_hasBinary(obj[i])) {\n              return true;\n          }\n      }\n    } else if (obj && 'object' == typeof obj) {\n      // see: https://github.com/Automattic/has-binary/pull/4\n      if (obj.toJSON && 'function' == typeof obj.toJSON) {\n        obj = obj.toJSON();\n      }\n\n      for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key) && _hasBinary(obj[key])) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  }\n\n  return _hasBinary(data);\n}\n","\n/**\n * Module exports.\n *\n * Logic borrowed from Modernizr:\n *\n *   - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cors.js\n */\n\ntry {\n  module.exports = typeof XMLHttpRequest !== 'undefined' &&\n    'withCredentials' in new XMLHttpRequest();\n} catch (err) {\n  // if XMLHttp support is disabled in IE then it will throw\n  // when trying to create\n  module.exports = false;\n}\n","\nvar indexOf = [].indexOf;\n\nmodule.exports = function(arr, obj){\n  if (indexOf) return arr.indexOf(obj);\n  for (var i = 0; i < arr.length; ++i) {\n    if (arr[i] === obj) return i;\n  }\n  return -1;\n};","module.exports = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n","/**\n * Gets the last element of `array`.\n *\n * @static\n * @memberOf _\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the last element of `array`.\n * @example\n *\n * _.last([1, 2, 3]);\n * // => 3\n */\nfunction last(array) {\n  var length = array ? array.length : 0;\n  return length ? array[length - 1] : undefined;\n}\n\nmodule.exports = last;\n","var isArray = require('../lang/isArray');\n\n/**\n * The inverse of `_.pairs`; this method returns an object composed from arrays\n * of property names and values. Provide either a single two dimensional array,\n * e.g. `[[key1, value1], [key2, value2]]` or two arrays, one of property names\n * and one of corresponding values.\n *\n * @static\n * @memberOf _\n * @alias object\n * @category Array\n * @param {Array} props The property names.\n * @param {Array} [values=[]] The property values.\n * @returns {Object} Returns the new object.\n * @example\n *\n * _.zipObject([['fred', 30], ['barney', 40]]);\n * // => { 'fred': 30, 'barney': 40 }\n *\n * _.zipObject(['fred', 'barney'], [30, 40]);\n * // => { 'fred': 30, 'barney': 40 }\n */\nfunction zipObject(props, values) {\n  var index = -1,\n      length = props ? props.length : 0,\n      result = {};\n\n  if (length && !values && !isArray(props[0])) {\n    values = [];\n  }\n  while (++index < length) {\n    var key = props[index];\n    if (values) {\n      result[key] = values[index];\n    } else if (key) {\n      result[key[0]] = key[1];\n    }\n  }\n  return result;\n}\n\nmodule.exports = zipObject;\n","var arrayFilter = require('../internal/arrayFilter'),\n    baseCallback = require('../internal/baseCallback'),\n    baseFilter = require('../internal/baseFilter'),\n    isArray = require('../lang/isArray');\n\n/**\n * Iterates over elements of `collection`, returning an array of all elements\n * `predicate` returns truthy for. The predicate is bound to `thisArg` and\n * invoked with three arguments: (value, index|key, collection).\n *\n * If a property name is provided for `predicate` the created `_.property`\n * style callback returns the property value of the given element.\n *\n * If a value is also provided for `thisArg` the created `_.matchesProperty`\n * style callback returns `true` for elements that have a matching property\n * value, else `false`.\n *\n * If an object is provided for `predicate` the created `_.matches` style\n * callback returns `true` for elements that have the properties of the given\n * object, else `false`.\n *\n * @static\n * @memberOf _\n * @alias select\n * @category Collection\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function|Object|string} [predicate=_.identity] The function invoked\n *  per iteration.\n * @param {*} [thisArg] The `this` binding of `predicate`.\n * @returns {Array} Returns the new filtered array.\n * @example\n *\n * _.filter([4, 5, 6], function(n) {\n *   return n % 2 == 0;\n * });\n * // => [4, 6]\n *\n * var users = [\n *   { 'user': 'barney', 'age': 36, 'active': true },\n *   { 'user': 'fred',   'age': 40, 'active': false }\n * ];\n *\n * // using the `_.matches` callback shorthand\n * _.pluck(_.filter(users, { 'age': 36, 'active': true }), 'user');\n * // => ['barney']\n *\n * // using the `_.matchesProperty` callback shorthand\n * _.pluck(_.filter(users, 'active', false), 'user');\n * // => ['fred']\n *\n * // using the `_.property` callback shorthand\n * _.pluck(_.filter(users, 'active'), 'user');\n * // => ['barney']\n */\nfunction filter(collection, predicate, thisArg) {\n  var func = isArray(collection) ? arrayFilter : baseFilter;\n  predicate = baseCallback(predicate, thisArg, 3);\n  return func(collection, predicate);\n}\n\nmodule.exports = filter;\n","var arrayEach = require('../internal/arrayEach'),\n    baseEach = require('../internal/baseEach'),\n    createForEach = require('../internal/createForEach');\n\n/**\n * Iterates over elements of `collection` invoking `iteratee` for each element.\n * The `iteratee` is bound to `thisArg` and invoked with three arguments:\n * (value, index|key, collection). Iteratee functions may exit iteration early\n * by explicitly returning `false`.\n *\n * **Note:** As with other \"Collections\" methods, objects with a \"length\" property\n * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn`\n * may be used for object iteration.\n *\n * @static\n * @memberOf _\n * @alias each\n * @category Collection\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @param {*} [thisArg] The `this` binding of `iteratee`.\n * @returns {Array|Object|string} Returns `collection`.\n * @example\n *\n * _([1, 2]).forEach(function(n) {\n *   console.log(n);\n * }).value();\n * // => logs each value from left to right and returns the array\n *\n * _.forEach({ 'a': 1, 'b': 2 }, function(n, key) {\n *   console.log(n, key);\n * });\n * // => logs each value-key pair and returns the object (iteration order is not guaranteed)\n */\nvar forEach = createForEach(arrayEach, baseEach);\n\nmodule.exports = forEach;\n","var arrayMap = require('../internal/arrayMap'),\n    baseCallback = require('../internal/baseCallback'),\n    baseMap = require('../internal/baseMap'),\n    isArray = require('../lang/isArray');\n\n/**\n * Creates an array of values by running each element in `collection` through\n * `iteratee`. The `iteratee` is bound to `thisArg` and invoked with three\n * arguments: (value, index|key, collection).\n *\n * If a property name is provided for `iteratee` the created `_.property`\n * style callback returns the property value of the given element.\n *\n * If a value is also provided for `thisArg` the created `_.matchesProperty`\n * style callback returns `true` for elements that have a matching property\n * value, else `false`.\n *\n * If an object is provided for `iteratee` the created `_.matches` style\n * callback returns `true` for elements that have the properties of the given\n * object, else `false`.\n *\n * Many lodash methods are guarded to work as iteratees for methods like\n * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.\n *\n * The guarded methods are:\n * `ary`, `callback`, `chunk`, `clone`, `create`, `curry`, `curryRight`,\n * `drop`, `dropRight`, `every`, `fill`, `flatten`, `invert`, `max`, `min`,\n * `parseInt`, `slice`, `sortBy`, `take`, `takeRight`, `template`, `trim`,\n * `trimLeft`, `trimRight`, `trunc`, `random`, `range`, `sample`, `some`,\n * `sum`, `uniq`, and `words`\n *\n * @static\n * @memberOf _\n * @alias collect\n * @category Collection\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function|Object|string} [iteratee=_.identity] The function invoked\n *  per iteration.\n * @param {*} [thisArg] The `this` binding of `iteratee`.\n * @returns {Array} Returns the new mapped array.\n * @example\n *\n * function timesThree(n) {\n *   return n * 3;\n * }\n *\n * _.map([1, 2], timesThree);\n * // => [3, 6]\n *\n * _.map({ 'a': 1, 'b': 2 }, timesThree);\n * // => [3, 6] (iteration order is not guaranteed)\n *\n * var users = [\n *   { 'user': 'barney' },\n *   { 'user': 'fred' }\n * ];\n *\n * // using the `_.property` callback shorthand\n * _.map(users, 'user');\n * // => ['barney', 'fred']\n */\nfunction map(collection, iteratee, thisArg) {\n  var func = isArray(collection) ? arrayMap : baseMap;\n  iteratee = baseCallback(iteratee, thisArg, 3);\n  return func(collection, iteratee);\n}\n\nmodule.exports = map;\n","var arraySome = require('../internal/arraySome'),\n    baseCallback = require('../internal/baseCallback'),\n    baseSome = require('../internal/baseSome'),\n    isArray = require('../lang/isArray'),\n    isIterateeCall = require('../internal/isIterateeCall');\n\n/**\n * Checks if `predicate` returns truthy for **any** element of `collection`.\n * The function returns as soon as it finds a passing value and does not iterate\n * over the entire collection. The predicate is bound to `thisArg` and invoked\n * with three arguments: (value, index|key, collection).\n *\n * If a property name is provided for `predicate` the created `_.property`\n * style callback returns the property value of the given element.\n *\n * If a value is also provided for `thisArg` the created `_.matchesProperty`\n * style callback returns `true` for elements that have a matching property\n * value, else `false`.\n *\n * If an object is provided for `predicate` the created `_.matches` style\n * callback returns `true` for elements that have the properties of the given\n * object, else `false`.\n *\n * @static\n * @memberOf _\n * @alias any\n * @category Collection\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function|Object|string} [predicate=_.identity] The function invoked\n *  per iteration.\n * @param {*} [thisArg] The `this` binding of `predicate`.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n * @example\n *\n * _.some([null, 0, 'yes', false], Boolean);\n * // => true\n *\n * var users = [\n *   { 'user': 'barney', 'active': true },\n *   { 'user': 'fred',   'active': false }\n * ];\n *\n * // using the `_.matches` callback shorthand\n * _.some(users, { 'user': 'barney', 'active': false });\n * // => false\n *\n * // using the `_.matchesProperty` callback shorthand\n * _.some(users, 'active', false);\n * // => true\n *\n * // using the `_.property` callback shorthand\n * _.some(users, 'active');\n * // => true\n */\nfunction some(collection, predicate, thisArg) {\n  var func = isArray(collection) ? arraySome : baseSome;\n  if (thisArg && isIterateeCall(collection, predicate, thisArg)) {\n    predicate = undefined;\n  }\n  if (typeof predicate != 'function' || thisArg !== undefined) {\n    predicate = baseCallback(predicate, thisArg, 3);\n  }\n  return func(collection, predicate);\n}\n\nmodule.exports = some;\n","/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Native method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * Creates a function that invokes `func` with the `this` binding of the\n * created function and arguments from `start` and beyond provided as an array.\n *\n * **Note:** This method is based on the [rest parameter](https://developer.mozilla.org/Web/JavaScript/Reference/Functions/rest_parameters).\n *\n * @static\n * @memberOf _\n * @category Function\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var say = _.restParam(function(what, names) {\n *   return what + ' ' + _.initial(names).join(', ') +\n *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);\n * });\n *\n * say('hello', 'fred', 'barney', 'pebbles');\n * // => 'hello fred, barney, & pebbles'\n */\nfunction restParam(func, start) {\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  start = nativeMax(start === undefined ? (func.length - 1) : (+start || 0), 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        rest = Array(length);\n\n    while (++index < length) {\n      rest[index] = args[start + index];\n    }\n    switch (start) {\n      case 0: return func.call(this, rest);\n      case 1: return func.call(this, args[0], rest);\n      case 2: return func.call(this, args[0], args[1], rest);\n    }\n    var otherArgs = Array(start + 1);\n    index = -1;\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = rest;\n    return func.apply(this, otherArgs);\n  };\n}\n\nmodule.exports = restParam;\n","/**\n * A specialized version of `_.forEach` for arrays without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\nfunction arrayEach(array, iteratee) {\n  var index = -1,\n      length = array.length;\n\n  while (++index < length) {\n    if (iteratee(array[index], index, array) === false) {\n      break;\n    }\n  }\n  return array;\n}\n\nmodule.exports = arrayEach;\n","/**\n * A specialized version of `_.filter` for arrays without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n  var index = -1,\n      length = array.length,\n      resIndex = -1,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result[++resIndex] = value;\n    }\n  }\n  return result;\n}\n\nmodule.exports = arrayFilter;\n","/**\n * A specialized version of `_.map` for arrays without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n  var index = -1,\n      length = array.length,\n      result = Array(length);\n\n  while (++index < length) {\n    result[index] = iteratee(array[index], index, array);\n  }\n  return result;\n}\n\nmodule.exports = arrayMap;\n","/**\n * A specialized version of `_.some` for arrays without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction arraySome(array, predicate) {\n  var index = -1,\n      length = array.length;\n\n  while (++index < length) {\n    if (predicate(array[index], index, array)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nmodule.exports = arraySome;\n","var keys = require('../object/keys');\n\n/**\n * A specialized version of `_.assign` for customizing assigned values without\n * support for argument juggling, multiple sources, and `this` binding `customizer`\n * functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {Function} customizer The function to customize assigned values.\n * @returns {Object} Returns `object`.\n */\nfunction assignWith(object, source, customizer) {\n  var index = -1,\n      props = keys(source),\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index],\n        value = object[key],\n        result = customizer(value, source[key], key, object, source);\n\n    if ((result === result ? (result !== value) : (value === value)) ||\n        (value === undefined && !(key in object))) {\n      object[key] = result;\n    }\n  }\n  return object;\n}\n\nmodule.exports = assignWith;\n","var baseCopy = require('./baseCopy'),\n    keys = require('../object/keys');\n\n/**\n * The base implementation of `_.assign` without support for argument juggling,\n * multiple sources, and `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssign(object, source) {\n  return source == null\n    ? object\n    : baseCopy(source, keys(source), object);\n}\n\nmodule.exports = baseAssign;\n","var baseMatches = require('./baseMatches'),\n    baseMatchesProperty = require('./baseMatchesProperty'),\n    bindCallback = require('./bindCallback'),\n    identity = require('../utility/identity'),\n    property = require('../utility/property');\n\n/**\n * The base implementation of `_.callback` which supports specifying the\n * number of arguments to provide to `func`.\n *\n * @private\n * @param {*} [func=_.identity] The value to convert to a callback.\n * @param {*} [thisArg] The `this` binding of `func`.\n * @param {number} [argCount] The number of arguments to provide to `func`.\n * @returns {Function} Returns the callback.\n */\nfunction baseCallback(func, thisArg, argCount) {\n  var type = typeof func;\n  if (type == 'function') {\n    return thisArg === undefined\n      ? func\n      : bindCallback(func, thisArg, argCount);\n  }\n  if (func == null) {\n    return identity;\n  }\n  if (type == 'object') {\n    return baseMatches(func);\n  }\n  return thisArg === undefined\n    ? property(func)\n    : baseMatchesProperty(func, thisArg);\n}\n\nmodule.exports = baseCallback;\n","/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property names to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @returns {Object} Returns `object`.\n */\nfunction baseCopy(source, props, object) {\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n    object[key] = source[key];\n  }\n  return object;\n}\n\nmodule.exports = baseCopy;\n","var baseForOwn = require('./baseForOwn'),\n    createBaseEach = require('./createBaseEach');\n\n/**\n * The base implementation of `_.forEach` without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array|Object|string} Returns `collection`.\n */\nvar baseEach = createBaseEach(baseForOwn);\n\nmodule.exports = baseEach;\n","var baseEach = require('./baseEach');\n\n/**\n * The base implementation of `_.filter` without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction baseFilter(collection, predicate) {\n  var result = [];\n  baseEach(collection, function(value, index, collection) {\n    if (predicate(value, index, collection)) {\n      result.push(value);\n    }\n  });\n  return result;\n}\n\nmodule.exports = baseFilter;\n","var createBaseFor = require('./createBaseFor');\n\n/**\n * The base implementation of `baseForIn` and `baseForOwn` which iterates\n * over `object` properties returned by `keysFunc` invoking `iteratee` for\n * each property. Iteratee functions may exit iteration early by explicitly\n * returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\nmodule.exports = baseFor;\n","var baseFor = require('./baseFor'),\n    keys = require('../object/keys');\n\n/**\n * The base implementation of `_.forOwn` without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Object} Returns `object`.\n */\nfunction baseForOwn(object, iteratee) {\n  return baseFor(object, iteratee, keys);\n}\n\nmodule.exports = baseForOwn;\n","var toObject = require('./toObject');\n\n/**\n * The base implementation of `get` without support for string paths\n * and default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} path The path of the property to get.\n * @param {string} [pathKey] The key representation of path.\n * @returns {*} Returns the resolved value.\n */\nfunction baseGet(object, path, pathKey) {\n  if (object == null) {\n    return;\n  }\n  if (pathKey !== undefined && pathKey in toObject(object)) {\n    path = [pathKey];\n  }\n  var index = 0,\n      length = path.length;\n\n  while (object != null && index < length) {\n    object = object[path[index++]];\n  }\n  return (index && index == length) ? object : undefined;\n}\n\nmodule.exports = baseGet;\n","var baseIsEqualDeep = require('./baseIsEqualDeep'),\n    isObject = require('../lang/isObject'),\n    isObjectLike = require('./isObjectLike');\n\n/**\n * The base implementation of `_.isEqual` without support for `this` binding\n * `customizer` functions.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {Function} [customizer] The function to customize comparing values.\n * @param {boolean} [isLoose] Specify performing partial comparisons.\n * @param {Array} [stackA] Tracks traversed `value` objects.\n * @param {Array} [stackB] Tracks traversed `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, customizer, isLoose, stackA, stackB) {\n  if (value === other) {\n    return true;\n  }\n  if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {\n    return value !== value && other !== other;\n  }\n  return baseIsEqualDeep(value, other, baseIsEqual, customizer, isLoose, stackA, stackB);\n}\n\nmodule.exports = baseIsEqual;\n","var equalArrays = require('./equalArrays'),\n    equalByTag = require('./equalByTag'),\n    equalObjects = require('./equalObjects'),\n    isArray = require('../lang/isArray'),\n    isTypedArray = require('../lang/isTypedArray');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    objectTag = '[object Object]';\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objToString = objectProto.toString;\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Function} [customizer] The function to customize comparing objects.\n * @param {boolean} [isLoose] Specify performing partial comparisons.\n * @param {Array} [stackA=[]] Tracks traversed `value` objects.\n * @param {Array} [stackB=[]] Tracks traversed `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA, stackB) {\n  var objIsArr = isArray(object),\n      othIsArr = isArray(other),\n      objTag = arrayTag,\n      othTag = arrayTag;\n\n  if (!objIsArr) {\n    objTag = objToString.call(object);\n    if (objTag == argsTag) {\n      objTag = objectTag;\n    } else if (objTag != objectTag) {\n      objIsArr = isTypedArray(object);\n    }\n  }\n  if (!othIsArr) {\n    othTag = objToString.call(other);\n    if (othTag == argsTag) {\n      othTag = objectTag;\n    } else if (othTag != objectTag) {\n      othIsArr = isTypedArray(other);\n    }\n  }\n  var objIsObj = objTag == objectTag,\n      othIsObj = othTag == objectTag,\n      isSameTag = objTag == othTag;\n\n  if (isSameTag && !(objIsArr || objIsObj)) {\n    return equalByTag(object, other, objTag);\n  }\n  if (!isLoose) {\n    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n    if (objIsWrapped || othIsWrapped) {\n      return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, isLoose, stackA, stackB);\n    }\n  }\n  if (!isSameTag) {\n    return false;\n  }\n  // Assume cyclic values are equal.\n  // For more information on detecting circular references see https://es5.github.io/#JO.\n  stackA || (stackA = []);\n  stackB || (stackB = []);\n\n  var length = stackA.length;\n  while (length--) {\n    if (stackA[length] == object) {\n      return stackB[length] == other;\n    }\n  }\n  // Add `object` and `other` to the stack of traversed objects.\n  stackA.push(object);\n  stackB.push(other);\n\n  var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, isLoose, stackA, stackB);\n\n  stackA.pop();\n  stackB.pop();\n\n  return result;\n}\n\nmodule.exports = baseIsEqualDeep;\n","var baseIsEqual = require('./baseIsEqual'),\n    toObject = require('./toObject');\n\n/**\n * The base implementation of `_.isMatch` without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @param {Array} matchData The propery names, values, and compare flags to match.\n * @param {Function} [customizer] The function to customize comparing objects.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n */\nfunction baseIsMatch(object, matchData, customizer) {\n  var index = matchData.length,\n      length = index,\n      noCustomizer = !customizer;\n\n  if (object == null) {\n    return !length;\n  }\n  object = toObject(object);\n  while (index--) {\n    var data = matchData[index];\n    if ((noCustomizer && data[2])\n          ? data[1] !== object[data[0]]\n          : !(data[0] in object)\n        ) {\n      return false;\n    }\n  }\n  while (++index < length) {\n    data = matchData[index];\n    var key = data[0],\n        objValue = object[key],\n        srcValue = data[1];\n\n    if (noCustomizer && data[2]) {\n      if (objValue === undefined && !(key in object)) {\n        return false;\n      }\n    } else {\n      var result = customizer ? customizer(objValue, srcValue, key) : undefined;\n      if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, true) : result)) {\n        return false;\n      }\n    }\n  }\n  return true;\n}\n\nmodule.exports = baseIsMatch;\n","var baseEach = require('./baseEach'),\n    isArrayLike = require('./isArrayLike');\n\n/**\n * The base implementation of `_.map` without support for callback shorthands\n * and `this` binding.\n *\n * @private\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction baseMap(collection, iteratee) {\n  var index = -1,\n      result = isArrayLike(collection) ? Array(collection.length) : [];\n\n  baseEach(collection, function(value, key, collection) {\n    result[++index] = iteratee(value, key, collection);\n  });\n  return result;\n}\n\nmodule.exports = baseMap;\n","var baseIsMatch = require('./baseIsMatch'),\n    getMatchData = require('./getMatchData'),\n    toObject = require('./toObject');\n\n/**\n * The base implementation of `_.matches` which does not clone `source`.\n *\n * @private\n * @param {Object} source The object of property values to match.\n * @returns {Function} Returns the new function.\n */\nfunction baseMatches(source) {\n  var matchData = getMatchData(source);\n  if (matchData.length == 1 && matchData[0][2]) {\n    var key = matchData[0][0],\n        value = matchData[0][1];\n\n    return function(object) {\n      if (object == null) {\n        return false;\n      }\n      return object[key] === value && (value !== undefined || (key in toObject(object)));\n    };\n  }\n  return function(object) {\n    return baseIsMatch(object, matchData);\n  };\n}\n\nmodule.exports = baseMatches;\n","var baseGet = require('./baseGet'),\n    baseIsEqual = require('./baseIsEqual'),\n    baseSlice = require('./baseSlice'),\n    isArray = require('../lang/isArray'),\n    isKey = require('./isKey'),\n    isStrictComparable = require('./isStrictComparable'),\n    last = require('../array/last'),\n    toObject = require('./toObject'),\n    toPath = require('./toPath');\n\n/**\n * The base implementation of `_.matchesProperty` which does not clone `srcValue`.\n *\n * @private\n * @param {string} path The path of the property to get.\n * @param {*} srcValue The value to compare.\n * @returns {Function} Returns the new function.\n */\nfunction baseMatchesProperty(path, srcValue) {\n  var isArr = isArray(path),\n      isCommon = isKey(path) && isStrictComparable(srcValue),\n      pathKey = (path + '');\n\n  path = toPath(path);\n  return function(object) {\n    if (object == null) {\n      return false;\n    }\n    var key = pathKey;\n    object = toObject(object);\n    if ((isArr || !isCommon) && !(key in object)) {\n      object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));\n      if (object == null) {\n        return false;\n      }\n      key = last(path);\n      object = toObject(object);\n    }\n    return object[key] === srcValue\n      ? (srcValue !== undefined || (key in object))\n      : baseIsEqual(srcValue, object[key], undefined, true);\n  };\n}\n\nmodule.exports = baseMatchesProperty;\n","/**\n * The base implementation of `_.property` without support for deep paths.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @returns {Function} Returns the new function.\n */\nfunction baseProperty(key) {\n  return function(object) {\n    return object == null ? undefined : object[key];\n  };\n}\n\nmodule.exports = baseProperty;\n","var baseGet = require('./baseGet'),\n    toPath = require('./toPath');\n\n/**\n * A specialized version of `baseProperty` which supports deep paths.\n *\n * @private\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new function.\n */\nfunction basePropertyDeep(path) {\n  var pathKey = (path + '');\n  path = toPath(path);\n  return function(object) {\n    return baseGet(object, path, pathKey);\n  };\n}\n\nmodule.exports = basePropertyDeep;\n","/**\n * The base implementation of `_.slice` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\nfunction baseSlice(array, start, end) {\n  var index = -1,\n      length = array.length;\n\n  start = start == null ? 0 : (+start || 0);\n  if (start < 0) {\n    start = -start > length ? 0 : (length + start);\n  }\n  end = (end === undefined || end > length) ? length : (+end || 0);\n  if (end < 0) {\n    end += length;\n  }\n  length = start > end ? 0 : ((end - start) >>> 0);\n  start >>>= 0;\n\n  var result = Array(length);\n  while (++index < length) {\n    result[index] = array[index + start];\n  }\n  return result;\n}\n\nmodule.exports = baseSlice;\n","var baseEach = require('./baseEach');\n\n/**\n * The base implementation of `_.some` without support for callback shorthands\n * and `this` binding.\n *\n * @private\n * @param {Array|Object|string} collection The collection to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction baseSome(collection, predicate) {\n  var result;\n\n  baseEach(collection, function(value, index, collection) {\n    result = predicate(value, index, collection);\n    return !result;\n  });\n  return !!result;\n}\n\nmodule.exports = baseSome;\n","/**\n * Converts `value` to a string if it's not one. An empty string is returned\n * for `null` or `undefined` values.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n  return value == null ? '' : (value + '');\n}\n\nmodule.exports = baseToString;\n","var identity = require('../utility/identity');\n\n/**\n * A specialized version of `baseCallback` which only supports `this` binding\n * and specifying the number of arguments to provide to `func`.\n *\n * @private\n * @param {Function} func The function to bind.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {number} [argCount] The number of arguments to provide to `func`.\n * @returns {Function} Returns the callback.\n */\nfunction bindCallback(func, thisArg, argCount) {\n  if (typeof func != 'function') {\n    return identity;\n  }\n  if (thisArg === undefined) {\n    return func;\n  }\n  switch (argCount) {\n    case 1: return function(value) {\n      return func.call(thisArg, value);\n    };\n    case 3: return function(value, index, collection) {\n      return func.call(thisArg, value, index, collection);\n    };\n    case 4: return function(accumulator, value, index, collection) {\n      return func.call(thisArg, accumulator, value, index, collection);\n    };\n    case 5: return function(value, other, key, object, source) {\n      return func.call(thisArg, value, other, key, object, source);\n    };\n  }\n  return function() {\n    return func.apply(thisArg, arguments);\n  };\n}\n\nmodule.exports = bindCallback;\n","var bindCallback = require('./bindCallback'),\n    isIterateeCall = require('./isIterateeCall'),\n    restParam = require('../function/restParam');\n\n/**\n * Creates a `_.assign`, `_.defaults`, or `_.merge` function.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return restParam(function(object, sources) {\n    var index = -1,\n        length = object == null ? 0 : sources.length,\n        customizer = length > 2 ? sources[length - 2] : undefined,\n        guard = length > 2 ? sources[2] : undefined,\n        thisArg = length > 1 ? sources[length - 1] : undefined;\n\n    if (typeof customizer == 'function') {\n      customizer = bindCallback(customizer, thisArg, 5);\n      length -= 2;\n    } else {\n      customizer = typeof thisArg == 'function' ? thisArg : undefined;\n      length -= (customizer ? 1 : 0);\n    }\n    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, customizer);\n      }\n    }\n    return object;\n  });\n}\n\nmodule.exports = createAssigner;\n","var getLength = require('./getLength'),\n    isLength = require('./isLength'),\n    toObject = require('./toObject');\n\n/**\n * Creates a `baseEach` or `baseEachRight` function.\n *\n * @private\n * @param {Function} eachFunc The function to iterate over a collection.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseEach(eachFunc, fromRight) {\n  return function(collection, iteratee) {\n    var length = collection ? getLength(collection) : 0;\n    if (!isLength(length)) {\n      return eachFunc(collection, iteratee);\n    }\n    var index = fromRight ? length : -1,\n        iterable = toObject(collection);\n\n    while ((fromRight ? index-- : ++index < length)) {\n      if (iteratee(iterable[index], index, iterable) === false) {\n        break;\n      }\n    }\n    return collection;\n  };\n}\n\nmodule.exports = createBaseEach;\n","var toObject = require('./toObject');\n\n/**\n * Creates a base function for `_.forIn` or `_.forInRight`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n  return function(object, iteratee, keysFunc) {\n    var iterable = toObject(object),\n        props = keysFunc(object),\n        length = props.length,\n        index = fromRight ? length : -1;\n\n    while ((fromRight ? index-- : ++index < length)) {\n      var key = props[index];\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n    return object;\n  };\n}\n\nmodule.exports = createBaseFor;\n","var bindCallback = require('./bindCallback'),\n    isArray = require('../lang/isArray');\n\n/**\n * Creates a function for `_.forEach` or `_.forEachRight`.\n *\n * @private\n * @param {Function} arrayFunc The function to iterate over an array.\n * @param {Function} eachFunc The function to iterate over a collection.\n * @returns {Function} Returns the new each function.\n */\nfunction createForEach(arrayFunc, eachFunc) {\n  return function(collection, iteratee, thisArg) {\n    return (typeof iteratee == 'function' && thisArg === undefined && isArray(collection))\n      ? arrayFunc(collection, iteratee)\n      : eachFunc(collection, bindCallback(iteratee, thisArg, 3));\n  };\n}\n\nmodule.exports = createForEach;\n","var bindCallback = require('./bindCallback');\n\n/**\n * Creates a function for `_.forOwn` or `_.forOwnRight`.\n *\n * @private\n * @param {Function} objectFunc The function to iterate over an object.\n * @returns {Function} Returns the new each function.\n */\nfunction createForOwn(objectFunc) {\n  return function(object, iteratee, thisArg) {\n    if (typeof iteratee != 'function' || thisArg !== undefined) {\n      iteratee = bindCallback(iteratee, thisArg, 3);\n    }\n    return objectFunc(object, iteratee);\n  };\n}\n\nmodule.exports = createForOwn;\n","var baseCallback = require('./baseCallback'),\n    baseForOwn = require('./baseForOwn');\n\n/**\n * Creates a function for `_.mapKeys` or `_.mapValues`.\n *\n * @private\n * @param {boolean} [isMapKeys] Specify mapping keys instead of values.\n * @returns {Function} Returns the new map function.\n */\nfunction createObjectMapper(isMapKeys) {\n  return function(object, iteratee, thisArg) {\n    var result = {};\n    iteratee = baseCallback(iteratee, thisArg, 3);\n\n    baseForOwn(object, function(value, key, object) {\n      var mapped = iteratee(value, key, object);\n      key = isMapKeys ? mapped : key;\n      value = isMapKeys ? value : mapped;\n      result[key] = value;\n    });\n    return result;\n  };\n}\n\nmodule.exports = createObjectMapper;\n","var arraySome = require('./arraySome');\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Function} [customizer] The function to customize comparing arrays.\n * @param {boolean} [isLoose] Specify performing partial comparisons.\n * @param {Array} [stackA] Tracks traversed `value` objects.\n * @param {Array} [stackB] Tracks traversed `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) {\n  var index = -1,\n      arrLength = array.length,\n      othLength = other.length;\n\n  if (arrLength != othLength && !(isLoose && othLength > arrLength)) {\n    return false;\n  }\n  // Ignore non-index properties.\n  while (++index < arrLength) {\n    var arrValue = array[index],\n        othValue = other[index],\n        result = customizer ? customizer(isLoose ? othValue : arrValue, isLoose ? arrValue : othValue, index) : undefined;\n\n    if (result !== undefined) {\n      if (result) {\n        continue;\n      }\n      return false;\n    }\n    // Recursively compare arrays (susceptible to call stack limits).\n    if (isLoose) {\n      if (!arraySome(other, function(othValue) {\n            return arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB);\n          })) {\n        return false;\n      }\n    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB))) {\n      return false;\n    }\n  }\n  return true;\n}\n\nmodule.exports = equalArrays;\n","/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    stringTag = '[object String]';\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag) {\n  switch (tag) {\n    case boolTag:\n    case dateTag:\n      // Coerce dates and booleans to numbers, dates to milliseconds and booleans\n      // to `1` or `0` treating invalid dates coerced to `NaN` as not equal.\n      return +object == +other;\n\n    case errorTag:\n      return object.name == other.name && object.message == other.message;\n\n    case numberTag:\n      // Treat `NaN` vs. `NaN` as equal.\n      return (object != +object)\n        ? other != +other\n        : object == +other;\n\n    case regexpTag:\n    case stringTag:\n      // Coerce regexes to strings and treat strings primitives and string\n      // objects as equal. See https://es5.github.io/#x15.10.6.4 for more details.\n      return object == (other + '');\n  }\n  return false;\n}\n\nmodule.exports = equalByTag;\n","var keys = require('../object/keys');\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Function} [customizer] The function to customize comparing values.\n * @param {boolean} [isLoose] Specify performing partial comparisons.\n * @param {Array} [stackA] Tracks traversed `value` objects.\n * @param {Array} [stackB] Tracks traversed `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, equalFunc, customizer, isLoose, stackA, stackB) {\n  var objProps = keys(object),\n      objLength = objProps.length,\n      othProps = keys(other),\n      othLength = othProps.length;\n\n  if (objLength != othLength && !isLoose) {\n    return false;\n  }\n  var index = objLength;\n  while (index--) {\n    var key = objProps[index];\n    if (!(isLoose ? key in other : hasOwnProperty.call(other, key))) {\n      return false;\n    }\n  }\n  var skipCtor = isLoose;\n  while (++index < objLength) {\n    key = objProps[index];\n    var objValue = object[key],\n        othValue = other[key],\n        result = customizer ? customizer(isLoose ? othValue : objValue, isLoose? objValue : othValue, key) : undefined;\n\n    // Recursively compare objects (susceptible to call stack limits).\n    if (!(result === undefined ? equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB) : result)) {\n      return false;\n    }\n    skipCtor || (skipCtor = key == 'constructor');\n  }\n  if (!skipCtor) {\n    var objCtor = object.constructor,\n        othCtor = other.constructor;\n\n    // Non `Object` object instances with different constructors are not equal.\n    if (objCtor != othCtor &&\n        ('constructor' in object && 'constructor' in other) &&\n        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n          typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nmodule.exports = equalObjects;\n","var baseProperty = require('./baseProperty');\n\n/**\n * Gets the \"length\" property value of `object`.\n *\n * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)\n * that affects Safari on at least iOS 8.1-8.3 ARM64.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {*} Returns the \"length\" value.\n */\nvar getLength = baseProperty('length');\n\nmodule.exports = getLength;\n","var isStrictComparable = require('./isStrictComparable'),\n    pairs = require('../object/pairs');\n\n/**\n * Gets the propery names, values, and compare flags of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the match data of `object`.\n */\nfunction getMatchData(object) {\n  var result = pairs(object),\n      length = result.length;\n\n  while (length--) {\n    result[length][2] = isStrictComparable(result[length][1]);\n  }\n  return result;\n}\n\nmodule.exports = getMatchData;\n","var isNative = require('../lang/isNative');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = object == null ? undefined : object[key];\n  return isNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n","var getLength = require('./getLength'),\n    isLength = require('./isLength');\n\n/**\n * Checks if `value` is array-like.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(getLength(value));\n}\n\nmodule.exports = isArrayLike;\n","/** Used to detect unsigned integer values. */\nvar reIsUint = /^\\d+$/;\n\n/**\n * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)\n * of an array-like value.\n */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return value > -1 && value % 1 == 0 && value < length;\n}\n\nmodule.exports = isIndex;\n","var isArrayLike = require('./isArrayLike'),\n    isIndex = require('./isIndex'),\n    isObject = require('../lang/isObject');\n\n/**\n * Checks if the provided arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n      ? (isArrayLike(object) && isIndex(index, object.length))\n      : (type == 'string' && index in object)) {\n    var other = object[index];\n    return value === value ? (value === other) : (other !== other);\n  }\n  return false;\n}\n\nmodule.exports = isIterateeCall;\n","var isArray = require('../lang/isArray'),\n    toObject = require('./toObject');\n\n/** Used to match property names within property paths. */\nvar reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\n\\\\]|\\\\.)*?\\1)\\]/,\n    reIsPlainProp = /^\\w*$/;\n\n/**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\nfunction isKey(value, object) {\n  var type = typeof value;\n  if ((type == 'string' && reIsPlainProp.test(value)) || type == 'number') {\n    return true;\n  }\n  if (isArray(value)) {\n    return false;\n  }\n  var result = !reIsDeepProp.test(value);\n  return result || (object != null && value in toObject(object));\n}\n\nmodule.exports = isKey;\n","/**\n * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)\n * of an array-like value.\n */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n */\nfunction isLength(value) {\n  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nmodule.exports = isLength;\n","/**\n * Checks if `value` is object-like.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var isObject = require('../lang/isObject');\n\n/**\n * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` if suitable for strict\n *  equality comparisons, else `false`.\n */\nfunction isStrictComparable(value) {\n  return value === value && !isObject(value);\n}\n\nmodule.exports = isStrictComparable;\n","var isArguments = require('../lang/isArguments'),\n    isArray = require('../lang/isArray'),\n    isIndex = require('./isIndex'),\n    isLength = require('./isLength'),\n    keysIn = require('../object/keysIn');\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A fallback implementation of `Object.keys` which creates an array of the\n * own enumerable property names of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction shimKeys(object) {\n  var props = keysIn(object),\n      propsLength = props.length,\n      length = propsLength && object.length;\n\n  var allowIndexes = !!length && isLength(length) &&\n    (isArray(object) || isArguments(object));\n\n  var index = -1,\n      result = [];\n\n  while (++index < propsLength) {\n    var key = props[index];\n    if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = shimKeys;\n","var isObject = require('../lang/isObject');\n\n/**\n * Converts `value` to an object if it's not one.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {Object} Returns the object.\n */\nfunction toObject(value) {\n  return isObject(value) ? value : Object(value);\n}\n\nmodule.exports = toObject;\n","var baseToString = require('./baseToString'),\n    isArray = require('../lang/isArray');\n\n/** Used to match property names within property paths. */\nvar rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\n\\\\]|\\\\.)*?)\\2)\\]/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/**\n * Converts `value` to property path array if it's not one.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {Array} Returns the property path array.\n */\nfunction toPath(value) {\n  if (isArray(value)) {\n    return value;\n  }\n  var result = [];\n  baseToString(value).replace(rePropName, function(match, number, quote, string) {\n    result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));\n  });\n  return result;\n}\n\nmodule.exports = toPath;\n","var isArrayLike = require('../internal/isArrayLike'),\n    isObjectLike = require('../internal/isObjectLike');\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Native method references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is classified as an `arguments` object.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nfunction isArguments(value) {\n  return isObjectLike(value) && isArrayLike(value) &&\n    hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');\n}\n\nmodule.exports = isArguments;\n","var getNative = require('../internal/getNative'),\n    isLength = require('../internal/isLength'),\n    isObjectLike = require('../internal/isObjectLike');\n\n/** `Object#toString` result references. */\nvar arrayTag = '[object Array]';\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objToString = objectProto.toString;\n\n/* Native method references for those with the same name as other `lodash` methods. */\nvar nativeIsArray = getNative(Array, 'isArray');\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(function() { return arguments; }());\n * // => false\n */\nvar isArray = nativeIsArray || function(value) {\n  return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;\n};\n\nmodule.exports = isArray;\n","var isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar funcTag = '[object Function]';\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objToString = objectProto.toString;\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in older versions of Chrome and Safari which return 'function' for regexes\n  // and Safari 8 which returns 'object' for typed array constructors.\n  return isObject(value) && objToString.call(value) == funcTag;\n}\n\nmodule.exports = isFunction;\n","var isFunction = require('./isFunction'),\n    isObjectLike = require('../internal/isObjectLike');\n\n/** Used to detect host constructors (Safari > 5). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar fnToString = Function.prototype.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  fnToString.call(hasOwnProperty).replace(/[\\\\^$.*+?()[\\]{}|]/g, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * Checks if `value` is a native function.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function, else `false`.\n * @example\n *\n * _.isNative(Array.prototype.push);\n * // => true\n *\n * _.isNative(_);\n * // => false\n */\nfunction isNative(value) {\n  if (value == null) {\n    return false;\n  }\n  if (isFunction(value)) {\n    return reIsNative.test(fnToString.call(value));\n  }\n  return isObjectLike(value) && reIsHostCtor.test(value);\n}\n\nmodule.exports = isNative;\n","/**\n * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.\n * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(1);\n * // => false\n */\nfunction isObject(value) {\n  // Avoid a V8 JIT bug in Chrome 19-20.\n  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","var isLength = require('../internal/isLength'),\n    isObjectLike = require('../internal/isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dateTag] = typedArrayTags[errorTag] =\ntypedArrayTags[funcTag] = typedArrayTags[mapTag] =\ntypedArrayTags[numberTag] = typedArrayTags[objectTag] =\ntypedArrayTags[regexpTag] = typedArrayTags[setTag] =\ntypedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objToString = objectProto.toString;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nfunction isTypedArray(value) {\n  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)];\n}\n\nmodule.exports = isTypedArray;\n","var assignWith = require('../internal/assignWith'),\n    baseAssign = require('../internal/baseAssign'),\n    createAssigner = require('../internal/createAssigner');\n\n/**\n * Assigns own enumerable properties of source object(s) to the destination\n * object. Subsequent sources overwrite property assignments of previous sources.\n * If `customizer` is provided it's invoked to produce the assigned values.\n * The `customizer` is bound to `thisArg` and invoked with five arguments:\n * (objectValue, sourceValue, key, object, source).\n *\n * **Note:** This method mutates `object` and is based on\n * [`Object.assign`](http://ecma-international.org/ecma-262/6.0/#sec-object.assign).\n *\n * @static\n * @memberOf _\n * @alias extend\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {*} [thisArg] The `this` binding of `customizer`.\n * @returns {Object} Returns `object`.\n * @example\n *\n * _.assign({ 'user': 'barney' }, { 'age': 40 }, { 'user': 'fred' });\n * // => { 'user': 'fred', 'age': 40 }\n *\n * // using a customizer callback\n * var defaults = _.partialRight(_.assign, function(value, other) {\n *   return _.isUndefined(value) ? other : value;\n * });\n *\n * defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });\n * // => { 'user': 'barney', 'age': 36 }\n */\nvar assign = createAssigner(function(object, source, customizer) {\n  return customizer\n    ? assignWith(object, source, customizer)\n    : baseAssign(object, source);\n});\n\nmodule.exports = assign;\n","var baseForOwn = require('../internal/baseForOwn'),\n    createForOwn = require('../internal/createForOwn');\n\n/**\n * Iterates over own enumerable properties of an object invoking `iteratee`\n * for each property. The `iteratee` is bound to `thisArg` and invoked with\n * three arguments: (value, key, object). Iteratee functions may exit iteration\n * early by explicitly returning `false`.\n *\n * @static\n * @memberOf _\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @param {*} [thisArg] The `this` binding of `iteratee`.\n * @returns {Object} Returns `object`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.forOwn(new Foo, function(value, key) {\n *   console.log(key);\n * });\n * // => logs 'a' and 'b' (iteration order is not guaranteed)\n */\nvar forOwn = createForOwn(baseForOwn);\n\nmodule.exports = forOwn;\n","var getNative = require('../internal/getNative'),\n    isArrayLike = require('../internal/isArrayLike'),\n    isObject = require('../lang/isObject'),\n    shimKeys = require('../internal/shimKeys');\n\n/* Native method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = getNative(Object, 'keys');\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nvar keys = !nativeKeys ? shimKeys : function(object) {\n  var Ctor = object == null ? undefined : object.constructor;\n  if ((typeof Ctor == 'function' && Ctor.prototype === object) ||\n      (typeof object != 'function' && isArrayLike(object))) {\n    return shimKeys(object);\n  }\n  return isObject(object) ? nativeKeys(object) : [];\n};\n\nmodule.exports = keys;\n","var isArguments = require('../lang/isArguments'),\n    isArray = require('../lang/isArray'),\n    isIndex = require('../internal/isIndex'),\n    isLength = require('../internal/isLength'),\n    isObject = require('../lang/isObject');\n\n/** Used for native method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  if (object == null) {\n    return [];\n  }\n  if (!isObject(object)) {\n    object = Object(object);\n  }\n  var length = object.length;\n  length = (length && isLength(length) &&\n    (isArray(object) || isArguments(object)) && length) || 0;\n\n  var Ctor = object.constructor,\n      index = -1,\n      isProto = typeof Ctor == 'function' && Ctor.prototype === object,\n      result = Array(length),\n      skipIndexes = length > 0;\n\n  while (++index < length) {\n    result[index] = (index + '');\n  }\n  for (var key in object) {\n    if (!(skipIndexes && isIndex(key, length)) &&\n        !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = keysIn;\n","var createObjectMapper = require('../internal/createObjectMapper');\n\n/**\n * Creates an object with the same keys as `object` and values generated by\n * running each own enumerable property of `object` through `iteratee`. The\n * iteratee function is bound to `thisArg` and invoked with three arguments:\n * (value, key, object).\n *\n * If a property name is provided for `iteratee` the created `_.property`\n * style callback returns the property value of the given element.\n *\n * If a value is also provided for `thisArg` the created `_.matchesProperty`\n * style callback returns `true` for elements that have a matching property\n * value, else `false`.\n *\n * If an object is provided for `iteratee` the created `_.matches` style\n * callback returns `true` for elements that have the properties of the given\n * object, else `false`.\n *\n * @static\n * @memberOf _\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function|Object|string} [iteratee=_.identity] The function invoked\n *  per iteration.\n * @param {*} [thisArg] The `this` binding of `iteratee`.\n * @returns {Object} Returns the new mapped object.\n * @example\n *\n * _.mapValues({ 'a': 1, 'b': 2 }, function(n) {\n *   return n * 3;\n * });\n * // => { 'a': 3, 'b': 6 }\n *\n * var users = {\n *   'fred':    { 'user': 'fred',    'age': 40 },\n *   'pebbles': { 'user': 'pebbles', 'age': 1 }\n * };\n *\n * // using the `_.property` callback shorthand\n * _.mapValues(users, 'age');\n * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n */\nvar mapValues = createObjectMapper();\n\nmodule.exports = mapValues;\n","var keys = require('./keys'),\n    toObject = require('../internal/toObject');\n\n/**\n * Creates a two dimensional array of the key-value pairs for `object`,\n * e.g. `[[key1, value1], [key2, value2]]`.\n *\n * @static\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the new array of key-value pairs.\n * @example\n *\n * _.pairs({ 'barney': 36, 'fred': 40 });\n * // => [['barney', 36], ['fred', 40]] (iteration order is not guaranteed)\n */\nfunction pairs(object) {\n  object = toObject(object);\n\n  var index = -1,\n      props = keys(object),\n      length = props.length,\n      result = Array(length);\n\n  while (++index < length) {\n    var key = props[index];\n    result[index] = [key, object[key]];\n  }\n  return result;\n}\n\nmodule.exports = pairs;\n","/**\n * This method returns the first argument provided to it.\n *\n * @static\n * @memberOf _\n * @category Utility\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'user': 'fred' };\n *\n * _.identity(object) === object;\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\nmodule.exports = identity;\n","var baseProperty = require('../internal/baseProperty'),\n    basePropertyDeep = require('../internal/basePropertyDeep'),\n    isKey = require('../internal/isKey');\n\n/**\n * Creates a function that returns the property value at `path` on a\n * given object.\n *\n * @static\n * @memberOf _\n * @category Utility\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var objects = [\n *   { 'a': { 'b': { 'c': 2 } } },\n *   { 'a': { 'b': { 'c': 1 } } }\n * ];\n *\n * _.map(objects, _.property('a.b.c'));\n * // => [2, 1]\n *\n * _.pluck(_.sortBy(objects, _.property(['a', 'b', 'c'])), 'a.b.c');\n * // => [1, 2]\n */\nfunction property(path) {\n  return isKey(path) ? baseProperty(path) : basePropertyDeep(path);\n}\n\nmodule.exports = property;\n","/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} options\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options){\n  options = options || {};\n  if ('string' == typeof val) return parse(val);\n  return options.long\n    ? long(val)\n    : short(val);\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = '' + str;\n  if (str.length > 10000) return;\n  var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str);\n  if (!match) return;\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction short(ms) {\n  if (ms >= d) return Math.round(ms / d) + 'd';\n  if (ms >= h) return Math.round(ms / h) + 'h';\n  if (ms >= m) return Math.round(ms / m) + 'm';\n  if (ms >= s) return Math.round(ms / s) + 's';\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction long(ms) {\n  return plural(ms, d, 'day')\n    || plural(ms, h, 'hour')\n    || plural(ms, m, 'minute')\n    || plural(ms, s, 'second')\n    || ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n  if (ms < n) return;\n  if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name;\n  return Math.ceil(ms / n) + ' ' + name + 's';\n}\n","/**\n * JSON parse.\n *\n * @see Based on jQuery#parseJSON (MIT) and JSON2\n * @api private\n */\n\nvar rvalidchars = /^[\\],:{}\\s]*$/;\nvar rvalidescape = /\\\\(?:[\"\\\\\\/bfnrt]|u[0-9a-fA-F]{4})/g;\nvar rvalidtokens = /\"[^\"\\\\\\n\\r]*\"|true|false|null|-?\\d+(?:\\.\\d*)?(?:[eE][+\\-]?\\d+)?/g;\nvar rvalidbraces = /(?:^|:|,)(?:\\s*\\[)+/g;\nvar rtrimLeft = /^\\s+/;\nvar rtrimRight = /\\s+$/;\n\nmodule.exports = function parsejson(data) {\n  if ('string' != typeof data || !data) {\n    return null;\n  }\n\n  data = data.replace(rtrimLeft, '').replace(rtrimRight, '');\n\n  // Attempt to parse using the native JSON parser first\n  if (global.JSON && JSON.parse) {\n    return JSON.parse(data);\n  }\n\n  if (rvalidchars.test(data.replace(rvalidescape, '@')\n      .replace(rvalidtokens, ']')\n      .replace(rvalidbraces, ''))) {\n    return (new Function('return ' + data))();\n  }\n};","/**\n * Compiles a querystring\n * Returns string representation of the object\n *\n * @param {Object}\n * @api private\n */\n\nexports.encode = function (obj) {\n  var str = '';\n\n  for (var i in obj) {\n    if (obj.hasOwnProperty(i)) {\n      if (str.length) str += '&';\n      str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);\n    }\n  }\n\n  return str;\n};\n\n/**\n * Parses a simple querystring into an object\n *\n * @param {String} qs\n * @api private\n */\n\nexports.decode = function(qs){\n  var qry = {};\n  var pairs = qs.split('&');\n  for (var i = 0, l = pairs.length; i < l; i++) {\n    var pair = pairs[i].split('=');\n    qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);\n  }\n  return qry;\n};\n","/**\n * Parses an URI\n *\n * @author Steven Levithan <stevenlevithan.com> (MIT license)\n * @api private\n */\n\nvar re = /^(?:(?![^:@]+:[^:@\\/]*@)(http|https|ws|wss):\\/\\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/;\n\nvar parts = [\n    'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'\n];\n\nmodule.exports = function parseuri(str) {\n    var src = str,\n        b = str.indexOf('['),\n        e = str.indexOf(']');\n\n    if (b != -1 && e != -1) {\n        str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);\n    }\n\n    var m = re.exec(str || ''),\n        uri = {},\n        i = 14;\n\n    while (i--) {\n        uri[parts[i]] = m[i] || '';\n    }\n\n    if (b != -1 && e != -1) {\n        uri.source = src;\n        uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');\n        uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');\n        uri.ipv6uri = true;\n    }\n\n    return uri;\n};\n","// shim for using process in browser\n\nvar process = module.exports = {};\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = setTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    clearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        setTimeout(drainQueue, 0);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","\n/**\n * Module dependencies.\n */\n\nvar url = require('./url');\nvar parser = require('socket.io-parser');\nvar Manager = require('./manager');\nvar debug = require('debug')('socket.io-client');\n\n/**\n * Module exports.\n */\n\nmodule.exports = exports = lookup;\n\n/**\n * Managers cache.\n */\n\nvar cache = exports.managers = {};\n\n/**\n * Looks up an existing `Manager` for multiplexing.\n * If the user summons:\n *\n *   `io('http://localhost/a');`\n *   `io('http://localhost/b');`\n *\n * We reuse the existing instance based on same scheme/port/host,\n * and we initialize sockets for each namespace.\n *\n * @api public\n */\n\nfunction lookup(uri, opts) {\n  if (typeof uri == 'object') {\n    opts = uri;\n    uri = undefined;\n  }\n\n  opts = opts || {};\n\n  var parsed = url(uri);\n  var source = parsed.source;\n  var id = parsed.id;\n  var path = parsed.path;\n  var sameNamespace = cache[id] && path in cache[id].nsps;\n  var newConnection = opts.forceNew || opts['force new connection'] ||\n                      false === opts.multiplex || sameNamespace;\n\n  var io;\n\n  if (newConnection) {\n    debug('ignoring socket cache for %s', source);\n    io = Manager(source, opts);\n  } else {\n    if (!cache[id]) {\n      debug('new io instance for %s', source);\n      cache[id] = Manager(source, opts);\n    }\n    io = cache[id];\n  }\n\n  return io.socket(parsed.path);\n}\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nexports.protocol = parser.protocol;\n\n/**\n * `connect`.\n *\n * @param {String} uri\n * @api public\n */\n\nexports.connect = lookup;\n\n/**\n * Expose constructors for standalone build.\n *\n * @api public\n */\n\nexports.Manager = require('./manager');\nexports.Socket = require('./socket');\n","\n/**\n * Module dependencies.\n */\n\nvar eio = require('engine.io-client');\nvar Socket = require('./socket');\nvar Emitter = require('component-emitter');\nvar parser = require('socket.io-parser');\nvar on = require('./on');\nvar bind = require('component-bind');\nvar debug = require('debug')('socket.io-client:manager');\nvar indexOf = require('indexof');\nvar Backoff = require('backo2');\n\n/**\n * IE6+ hasOwnProperty\n */\n\nvar has = Object.prototype.hasOwnProperty;\n\n/**\n * Module exports\n */\n\nmodule.exports = Manager;\n\n/**\n * `Manager` constructor.\n *\n * @param {String} engine instance or engine uri/opts\n * @param {Object} options\n * @api public\n */\n\nfunction Manager(uri, opts){\n  if (!(this instanceof Manager)) return new Manager(uri, opts);\n  if (uri && ('object' == typeof uri)) {\n    opts = uri;\n    uri = undefined;\n  }\n  opts = opts || {};\n\n  opts.path = opts.path || '/socket.io';\n  this.nsps = {};\n  this.subs = [];\n  this.opts = opts;\n  this.reconnection(opts.reconnection !== false);\n  this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);\n  this.reconnectionDelay(opts.reconnectionDelay || 1000);\n  this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);\n  this.randomizationFactor(opts.randomizationFactor || 0.5);\n  this.backoff = new Backoff({\n    min: this.reconnectionDelay(),\n    max: this.reconnectionDelayMax(),\n    jitter: this.randomizationFactor()\n  });\n  this.timeout(null == opts.timeout ? 20000 : opts.timeout);\n  this.readyState = 'closed';\n  this.uri = uri;\n  this.connecting = [];\n  this.lastPing = null;\n  this.encoding = false;\n  this.packetBuffer = [];\n  this.encoder = new parser.Encoder();\n  this.decoder = new parser.Decoder();\n  this.autoConnect = opts.autoConnect !== false;\n  if (this.autoConnect) this.open();\n}\n\n/**\n * Propagate given event to sockets and emit on `this`\n *\n * @api private\n */\n\nManager.prototype.emitAll = function() {\n  this.emit.apply(this, arguments);\n  for (var nsp in this.nsps) {\n    if (has.call(this.nsps, nsp)) {\n      this.nsps[nsp].emit.apply(this.nsps[nsp], arguments);\n    }\n  }\n};\n\n/**\n * Update `socket.id` of all sockets\n *\n * @api private\n */\n\nManager.prototype.updateSocketIds = function(){\n  for (var nsp in this.nsps) {\n    if (has.call(this.nsps, nsp)) {\n      this.nsps[nsp].id = this.engine.id;\n    }\n  }\n};\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Manager.prototype);\n\n/**\n * Sets the `reconnection` config.\n *\n * @param {Boolean} true/false if it should automatically reconnect\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnection = function(v){\n  if (!arguments.length) return this._reconnection;\n  this._reconnection = !!v;\n  return this;\n};\n\n/**\n * Sets the reconnection attempts config.\n *\n * @param {Number} max reconnection attempts before giving up\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionAttempts = function(v){\n  if (!arguments.length) return this._reconnectionAttempts;\n  this._reconnectionAttempts = v;\n  return this;\n};\n\n/**\n * Sets the delay between reconnections.\n *\n * @param {Number} delay\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionDelay = function(v){\n  if (!arguments.length) return this._reconnectionDelay;\n  this._reconnectionDelay = v;\n  this.backoff && this.backoff.setMin(v);\n  return this;\n};\n\nManager.prototype.randomizationFactor = function(v){\n  if (!arguments.length) return this._randomizationFactor;\n  this._randomizationFactor = v;\n  this.backoff && this.backoff.setJitter(v);\n  return this;\n};\n\n/**\n * Sets the maximum delay between reconnections.\n *\n * @param {Number} delay\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionDelayMax = function(v){\n  if (!arguments.length) return this._reconnectionDelayMax;\n  this._reconnectionDelayMax = v;\n  this.backoff && this.backoff.setMax(v);\n  return this;\n};\n\n/**\n * Sets the connection timeout. `false` to disable\n *\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.timeout = function(v){\n  if (!arguments.length) return this._timeout;\n  this._timeout = v;\n  return this;\n};\n\n/**\n * Starts trying to reconnect if reconnection is enabled and we have not\n * started reconnecting yet\n *\n * @api private\n */\n\nManager.prototype.maybeReconnectOnOpen = function() {\n  // Only try to reconnect if it's the first time we're connecting\n  if (!this.reconnecting && this._reconnection && this.backoff.attempts === 0) {\n    // keeps reconnection from firing twice for the same reconnection loop\n    this.reconnect();\n  }\n};\n\n\n/**\n * Sets the current transport `socket`.\n *\n * @param {Function} optional, callback\n * @return {Manager} self\n * @api public\n */\n\nManager.prototype.open =\nManager.prototype.connect = function(fn){\n  debug('readyState %s', this.readyState);\n  if (~this.readyState.indexOf('open')) return this;\n\n  debug('opening %s', this.uri);\n  this.engine = eio(this.uri, this.opts);\n  var socket = this.engine;\n  var self = this;\n  this.readyState = 'opening';\n  this.skipReconnect = false;\n\n  // emit `open`\n  var openSub = on(socket, 'open', function() {\n    self.onopen();\n    fn && fn();\n  });\n\n  // emit `connect_error`\n  var errorSub = on(socket, 'error', function(data){\n    debug('connect_error');\n    self.cleanup();\n    self.readyState = 'closed';\n    self.emitAll('connect_error', data);\n    if (fn) {\n      var err = new Error('Connection error');\n      err.data = data;\n      fn(err);\n    } else {\n      // Only do this if there is no fn to handle the error\n      self.maybeReconnectOnOpen();\n    }\n  });\n\n  // emit `connect_timeout`\n  if (false !== this._timeout) {\n    var timeout = this._timeout;\n    debug('connect attempt will timeout after %d', timeout);\n\n    // set timer\n    var timer = setTimeout(function(){\n      debug('connect attempt timed out after %d', timeout);\n      openSub.destroy();\n      socket.close();\n      socket.emit('error', 'timeout');\n      self.emitAll('connect_timeout', timeout);\n    }, timeout);\n\n    this.subs.push({\n      destroy: function(){\n        clearTimeout(timer);\n      }\n    });\n  }\n\n  this.subs.push(openSub);\n  this.subs.push(errorSub);\n\n  return this;\n};\n\n/**\n * Called upon transport open.\n *\n * @api private\n */\n\nManager.prototype.onopen = function(){\n  debug('open');\n\n  // clear old subs\n  this.cleanup();\n\n  // mark as open\n  this.readyState = 'open';\n  this.emit('open');\n\n  // add new subs\n  var socket = this.engine;\n  this.subs.push(on(socket, 'data', bind(this, 'ondata')));\n  this.subs.push(on(socket, 'ping', bind(this, 'onping')));\n  this.subs.push(on(socket, 'pong', bind(this, 'onpong')));\n  this.subs.push(on(socket, 'error', bind(this, 'onerror')));\n  this.subs.push(on(socket, 'close', bind(this, 'onclose')));\n  this.subs.push(on(this.decoder, 'decoded', bind(this, 'ondecoded')));\n};\n\n/**\n * Called upon a ping.\n *\n * @api private\n */\n\nManager.prototype.onping = function(){\n  this.lastPing = new Date;\n  this.emitAll('ping');\n};\n\n/**\n * Called upon a packet.\n *\n * @api private\n */\n\nManager.prototype.onpong = function(){\n  this.emitAll('pong', new Date - this.lastPing);\n};\n\n/**\n * Called with data.\n *\n * @api private\n */\n\nManager.prototype.ondata = function(data){\n  this.decoder.add(data);\n};\n\n/**\n * Called when parser fully decodes a packet.\n *\n * @api private\n */\n\nManager.prototype.ondecoded = function(packet) {\n  this.emit('packet', packet);\n};\n\n/**\n * Called upon socket error.\n *\n * @api private\n */\n\nManager.prototype.onerror = function(err){\n  debug('error', err);\n  this.emitAll('error', err);\n};\n\n/**\n * Creates a new socket for the given `nsp`.\n *\n * @return {Socket}\n * @api public\n */\n\nManager.prototype.socket = function(nsp){\n  var socket = this.nsps[nsp];\n  if (!socket) {\n    socket = new Socket(this, nsp);\n    this.nsps[nsp] = socket;\n    var self = this;\n    socket.on('connecting', onConnecting);\n    socket.on('connect', function(){\n      socket.id = self.engine.id;\n    });\n\n    if (this.autoConnect) {\n      // manually call here since connecting evnet is fired before listening\n      onConnecting();\n    }\n  }\n\n  function onConnecting() {\n    if (!~indexOf(self.connecting, socket)) {\n      self.connecting.push(socket);\n    }\n  }\n\n  return socket;\n};\n\n/**\n * Called upon a socket close.\n *\n * @param {Socket} socket\n */\n\nManager.prototype.destroy = function(socket){\n  var index = indexOf(this.connecting, socket);\n  if (~index) this.connecting.splice(index, 1);\n  if (this.connecting.length) return;\n\n  this.close();\n};\n\n/**\n * Writes a packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nManager.prototype.packet = function(packet){\n  debug('writing packet %j', packet);\n  var self = this;\n\n  if (!self.encoding) {\n    // encode, then write to engine with result\n    self.encoding = true;\n    this.encoder.encode(packet, function(encodedPackets) {\n      for (var i = 0; i < encodedPackets.length; i++) {\n        self.engine.write(encodedPackets[i], packet.options);\n      }\n      self.encoding = false;\n      self.processPacketQueue();\n    });\n  } else { // add packet to the queue\n    self.packetBuffer.push(packet);\n  }\n};\n\n/**\n * If packet buffer is non-empty, begins encoding the\n * next packet in line.\n *\n * @api private\n */\n\nManager.prototype.processPacketQueue = function() {\n  if (this.packetBuffer.length > 0 && !this.encoding) {\n    var pack = this.packetBuffer.shift();\n    this.packet(pack);\n  }\n};\n\n/**\n * Clean up transport subscriptions and packet buffer.\n *\n * @api private\n */\n\nManager.prototype.cleanup = function(){\n  debug('cleanup');\n\n  var sub;\n  while (sub = this.subs.shift()) sub.destroy();\n\n  this.packetBuffer = [];\n  this.encoding = false;\n  this.lastPing = null;\n\n  this.decoder.destroy();\n};\n\n/**\n * Close the current socket.\n *\n * @api private\n */\n\nManager.prototype.close =\nManager.prototype.disconnect = function(){\n  debug('disconnect');\n  this.skipReconnect = true;\n  this.reconnecting = false;\n  if ('opening' == this.readyState) {\n    // `onclose` will not fire because\n    // an open event never happened\n    this.cleanup();\n  }\n  this.backoff.reset();\n  this.readyState = 'closed';\n  if (this.engine) this.engine.close();\n};\n\n/**\n * Called upon engine close.\n *\n * @api private\n */\n\nManager.prototype.onclose = function(reason){\n  debug('onclose');\n\n  this.cleanup();\n  this.backoff.reset();\n  this.readyState = 'closed';\n  this.emit('close', reason);\n\n  if (this._reconnection && !this.skipReconnect) {\n    this.reconnect();\n  }\n};\n\n/**\n * Attempt a reconnection.\n *\n * @api private\n */\n\nManager.prototype.reconnect = function(){\n  if (this.reconnecting || this.skipReconnect) return this;\n\n  var self = this;\n\n  if (this.backoff.attempts >= this._reconnectionAttempts) {\n    debug('reconnect failed');\n    this.backoff.reset();\n    this.emitAll('reconnect_failed');\n    this.reconnecting = false;\n  } else {\n    var delay = this.backoff.duration();\n    debug('will wait %dms before reconnect attempt', delay);\n\n    this.reconnecting = true;\n    var timer = setTimeout(function(){\n      if (self.skipReconnect) return;\n\n      debug('attempting reconnect');\n      self.emitAll('reconnect_attempt', self.backoff.attempts);\n      self.emitAll('reconnecting', self.backoff.attempts);\n\n      // check again for the case socket closed in above events\n      if (self.skipReconnect) return;\n\n      self.open(function(err){\n        if (err) {\n          debug('reconnect attempt error');\n          self.reconnecting = false;\n          self.reconnect();\n          self.emitAll('reconnect_error', err.data);\n        } else {\n          debug('reconnect success');\n          self.onreconnect();\n        }\n      });\n    }, delay);\n\n    this.subs.push({\n      destroy: function(){\n        clearTimeout(timer);\n      }\n    });\n  }\n};\n\n/**\n * Called upon successful reconnect.\n *\n * @api private\n */\n\nManager.prototype.onreconnect = function(){\n  var attempt = this.backoff.attempts;\n  this.reconnecting = false;\n  this.backoff.reset();\n  this.updateSocketIds();\n  this.emitAll('reconnect', attempt);\n};\n","\n/**\n * Module exports.\n */\n\nmodule.exports = on;\n\n/**\n * Helper for subscriptions.\n *\n * @param {Object|EventEmitter} obj with `Emitter` mixin or `EventEmitter`\n * @param {String} event name\n * @param {Function} callback\n * @api public\n */\n\nfunction on(obj, ev, fn) {\n  obj.on(ev, fn);\n  return {\n    destroy: function(){\n      obj.removeListener(ev, fn);\n    }\n  };\n}\n","\n/**\n * Module dependencies.\n */\n\nvar parser = require('socket.io-parser');\nvar Emitter = require('component-emitter');\nvar toArray = require('to-array');\nvar on = require('./on');\nvar bind = require('component-bind');\nvar debug = require('debug')('socket.io-client:socket');\nvar hasBin = require('has-binary');\n\n/**\n * Module exports.\n */\n\nmodule.exports = exports = Socket;\n\n/**\n * Internal events (blacklisted).\n * These events can't be emitted by the user.\n *\n * @api private\n */\n\nvar events = {\n  connect: 1,\n  connect_error: 1,\n  connect_timeout: 1,\n  connecting: 1,\n  disconnect: 1,\n  error: 1,\n  reconnect: 1,\n  reconnect_attempt: 1,\n  reconnect_failed: 1,\n  reconnect_error: 1,\n  reconnecting: 1,\n  ping: 1,\n  pong: 1\n};\n\n/**\n * Shortcut to `Emitter#emit`.\n */\n\nvar emit = Emitter.prototype.emit;\n\n/**\n * `Socket` constructor.\n *\n * @api public\n */\n\nfunction Socket(io, nsp){\n  this.io = io;\n  this.nsp = nsp;\n  this.json = this; // compat\n  this.ids = 0;\n  this.acks = {};\n  this.receiveBuffer = [];\n  this.sendBuffer = [];\n  this.connected = false;\n  this.disconnected = true;\n  if (this.io.autoConnect) this.open();\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Socket.prototype);\n\n/**\n * Subscribe to open, close and packet events\n *\n * @api private\n */\n\nSocket.prototype.subEvents = function() {\n  if (this.subs) return;\n\n  var io = this.io;\n  this.subs = [\n    on(io, 'open', bind(this, 'onopen')),\n    on(io, 'packet', bind(this, 'onpacket')),\n    on(io, 'close', bind(this, 'onclose'))\n  ];\n};\n\n/**\n * \"Opens\" the socket.\n *\n * @api public\n */\n\nSocket.prototype.open =\nSocket.prototype.connect = function(){\n  if (this.connected) return this;\n\n  this.subEvents();\n  this.io.open(); // ensure open\n  if ('open' == this.io.readyState) this.onopen();\n  this.emit('connecting');\n  return this;\n};\n\n/**\n * Sends a `message` event.\n *\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.send = function(){\n  var args = toArray(arguments);\n  args.unshift('message');\n  this.emit.apply(this, args);\n  return this;\n};\n\n/**\n * Override `emit`.\n * If the event is in `events`, it's emitted normally.\n *\n * @param {String} event name\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.emit = function(ev){\n  if (events.hasOwnProperty(ev)) {\n    emit.apply(this, arguments);\n    return this;\n  }\n\n  var args = toArray(arguments);\n  var parserType = parser.EVENT; // default\n  if (hasBin(args)) { parserType = parser.BINARY_EVENT; } // binary\n  var packet = { type: parserType, data: args };\n\n  packet.options = {};\n  packet.options.compress = !this.flags || false !== this.flags.compress;\n\n  // event ack callback\n  if ('function' == typeof args[args.length - 1]) {\n    debug('emitting packet with ack id %d', this.ids);\n    this.acks[this.ids] = args.pop();\n    packet.id = this.ids++;\n  }\n\n  if (this.connected) {\n    this.packet(packet);\n  } else {\n    this.sendBuffer.push(packet);\n  }\n\n  delete this.flags;\n\n  return this;\n};\n\n/**\n * Sends a packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.packet = function(packet){\n  packet.nsp = this.nsp;\n  this.io.packet(packet);\n};\n\n/**\n * Called upon engine `open`.\n *\n * @api private\n */\n\nSocket.prototype.onopen = function(){\n  debug('transport is open - connecting');\n\n  // write connect packet if necessary\n  if ('/' != this.nsp) {\n    this.packet({ type: parser.CONNECT });\n  }\n};\n\n/**\n * Called upon engine `close`.\n *\n * @param {String} reason\n * @api private\n */\n\nSocket.prototype.onclose = function(reason){\n  debug('close (%s)', reason);\n  this.connected = false;\n  this.disconnected = true;\n  delete this.id;\n  this.emit('disconnect', reason);\n};\n\n/**\n * Called with socket packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onpacket = function(packet){\n  if (packet.nsp != this.nsp) return;\n\n  switch (packet.type) {\n    case parser.CONNECT:\n      this.onconnect();\n      break;\n\n    case parser.EVENT:\n      this.onevent(packet);\n      break;\n\n    case parser.BINARY_EVENT:\n      this.onevent(packet);\n      break;\n\n    case parser.ACK:\n      this.onack(packet);\n      break;\n\n    case parser.BINARY_ACK:\n      this.onack(packet);\n      break;\n\n    case parser.DISCONNECT:\n      this.ondisconnect();\n      break;\n\n    case parser.ERROR:\n      this.emit('error', packet.data);\n      break;\n  }\n};\n\n/**\n * Called upon a server event.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onevent = function(packet){\n  var args = packet.data || [];\n  debug('emitting event %j', args);\n\n  if (null != packet.id) {\n    debug('attaching ack callback to event');\n    args.push(this.ack(packet.id));\n  }\n\n  if (this.connected) {\n    emit.apply(this, args);\n  } else {\n    this.receiveBuffer.push(args);\n  }\n};\n\n/**\n * Produces an ack callback to emit with an event.\n *\n * @api private\n */\n\nSocket.prototype.ack = function(id){\n  var self = this;\n  var sent = false;\n  return function(){\n    // prevent double callbacks\n    if (sent) return;\n    sent = true;\n    var args = toArray(arguments);\n    debug('sending ack %j', args);\n\n    var type = hasBin(args) ? parser.BINARY_ACK : parser.ACK;\n    self.packet({\n      type: type,\n      id: id,\n      data: args\n    });\n  };\n};\n\n/**\n * Called upon a server acknowlegement.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onack = function(packet){\n  var ack = this.acks[packet.id];\n  if ('function' == typeof ack) {\n    debug('calling ack %s with %j', packet.id, packet.data);\n    ack.apply(this, packet.data);\n    delete this.acks[packet.id];\n  } else {\n    debug('bad ack %s', packet.id);\n  }\n};\n\n/**\n * Called upon server connect.\n *\n * @api private\n */\n\nSocket.prototype.onconnect = function(){\n  this.connected = true;\n  this.disconnected = false;\n  this.emit('connect');\n  this.emitBuffered();\n};\n\n/**\n * Emit buffered events (received and emitted).\n *\n * @api private\n */\n\nSocket.prototype.emitBuffered = function(){\n  var i;\n  for (i = 0; i < this.receiveBuffer.length; i++) {\n    emit.apply(this, this.receiveBuffer[i]);\n  }\n  this.receiveBuffer = [];\n\n  for (i = 0; i < this.sendBuffer.length; i++) {\n    this.packet(this.sendBuffer[i]);\n  }\n  this.sendBuffer = [];\n};\n\n/**\n * Called upon server disconnect.\n *\n * @api private\n */\n\nSocket.prototype.ondisconnect = function(){\n  debug('server disconnect (%s)', this.nsp);\n  this.destroy();\n  this.onclose('io server disconnect');\n};\n\n/**\n * Called upon forced client/server side disconnections,\n * this method ensures the manager stops tracking us and\n * that reconnections don't get triggered for this.\n *\n * @api private.\n */\n\nSocket.prototype.destroy = function(){\n  if (this.subs) {\n    // clean subscriptions to avoid reconnections\n    for (var i = 0; i < this.subs.length; i++) {\n      this.subs[i].destroy();\n    }\n    this.subs = null;\n  }\n\n  this.io.destroy(this);\n};\n\n/**\n * Disconnects the socket manually.\n *\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.close =\nSocket.prototype.disconnect = function(){\n  if (this.connected) {\n    debug('performing disconnect (%s)', this.nsp);\n    this.packet({ type: parser.DISCONNECT });\n  }\n\n  // remove socket from pool\n  this.destroy();\n\n  if (this.connected) {\n    // fire events\n    this.onclose('io client disconnect');\n  }\n  return this;\n};\n\n/**\n * Sets the compress flag.\n *\n * @param {Boolean} if `true`, compresses the sending data\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.compress = function(compress){\n  this.flags = this.flags || {};\n  this.flags.compress = compress;\n  return this;\n};\n","\n/**\n * Module dependencies.\n */\n\nvar parseuri = require('parseuri');\nvar debug = require('debug')('socket.io-client:url');\n\n/**\n * Module exports.\n */\n\nmodule.exports = url;\n\n/**\n * URL parser.\n *\n * @param {String} url\n * @param {Object} An object meant to mimic window.location.\n *                 Defaults to window.location.\n * @api public\n */\n\nfunction url(uri, loc){\n  var obj = uri;\n\n  // default to window.location\n  var loc = loc || global.location;\n  if (null == uri) uri = loc.protocol + '//' + loc.host;\n\n  // relative path support\n  if ('string' == typeof uri) {\n    if ('/' == uri.charAt(0)) {\n      if ('/' == uri.charAt(1)) {\n        uri = loc.protocol + uri;\n      } else {\n        uri = loc.host + uri;\n      }\n    }\n\n    if (!/^(https?|wss?):\\/\\//.test(uri)) {\n      debug('protocol-less url %s', uri);\n      if ('undefined' != typeof loc) {\n        uri = loc.protocol + '//' + uri;\n      } else {\n        uri = 'https://' + uri;\n      }\n    }\n\n    // parse\n    debug('parse %s', uri);\n    obj = parseuri(uri);\n  }\n\n  // make sure we treat `localhost:80` and `localhost` equally\n  if (!obj.port) {\n    if (/^(http|ws)$/.test(obj.protocol)) {\n      obj.port = '80';\n    }\n    else if (/^(http|ws)s$/.test(obj.protocol)) {\n      obj.port = '443';\n    }\n  }\n\n  obj.path = obj.path || '/';\n\n  var ipv6 = obj.host.indexOf(':') !== -1;\n  var host = ipv6 ? '[' + obj.host + ']' : obj.host;\n\n  // define unique id\n  obj.id = obj.protocol + '://' + host + ':' + obj.port;\n  // define href\n  obj.href = obj.protocol + '://' + host + (loc && loc.port == obj.port ? '' : (':' + obj.port));\n\n  return obj;\n}\n","\n/**\n * Expose `Emitter`.\n */\n\nmodule.exports = Emitter;\n\n/**\n * Initialize a new `Emitter`.\n *\n * @api public\n */\n\nfunction Emitter(obj) {\n  if (obj) return mixin(obj);\n};\n\n/**\n * Mixin the emitter properties.\n *\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nfunction mixin(obj) {\n  for (var key in Emitter.prototype) {\n    obj[key] = Emitter.prototype[key];\n  }\n  return obj;\n}\n\n/**\n * Listen on the given `event` with `fn`.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.on =\nEmitter.prototype.addEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])\n    .push(fn);\n  return this;\n};\n\n/**\n * Adds an `event` listener that will be invoked a single\n * time then automatically removed.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.once = function(event, fn){\n  function on() {\n    this.off(event, on);\n    fn.apply(this, arguments);\n  }\n\n  on.fn = fn;\n  this.on(event, on);\n  return this;\n};\n\n/**\n * Remove the given callback for `event` or all\n * registered callbacks.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.off =\nEmitter.prototype.removeListener =\nEmitter.prototype.removeAllListeners =\nEmitter.prototype.removeEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n\n  // all\n  if (0 == arguments.length) {\n    this._callbacks = {};\n    return this;\n  }\n\n  // specific event\n  var callbacks = this._callbacks['$' + event];\n  if (!callbacks) return this;\n\n  // remove all handlers\n  if (1 == arguments.length) {\n    delete this._callbacks['$' + event];\n    return this;\n  }\n\n  // remove specific handler\n  var cb;\n  for (var i = 0; i < callbacks.length; i++) {\n    cb = callbacks[i];\n    if (cb === fn || cb.fn === fn) {\n      callbacks.splice(i, 1);\n      break;\n    }\n  }\n  return this;\n};\n\n/**\n * Emit `event` with the given args.\n *\n * @param {String} event\n * @param {Mixed} ...\n * @return {Emitter}\n */\n\nEmitter.prototype.emit = function(event){\n  this._callbacks = this._callbacks || {};\n  var args = [].slice.call(arguments, 1)\n    , callbacks = this._callbacks['$' + event];\n\n  if (callbacks) {\n    callbacks = callbacks.slice(0);\n    for (var i = 0, len = callbacks.length; i < len; ++i) {\n      callbacks[i].apply(this, args);\n    }\n  }\n\n  return this;\n};\n\n/**\n * Return array of callbacks for `event`.\n *\n * @param {String} event\n * @return {Array}\n * @api public\n */\n\nEmitter.prototype.listeners = function(event){\n  this._callbacks = this._callbacks || {};\n  return this._callbacks['$' + event] || [];\n};\n\n/**\n * Check if this emitter has `event` handlers.\n *\n * @param {String} event\n * @return {Boolean}\n * @api public\n */\n\nEmitter.prototype.hasListeners = function(event){\n  return !! this.listeners(event).length;\n};\n","/*global Blob,File*/\n\n/**\n * Module requirements\n */\n\nvar isArray = require('isarray');\nvar isBuf = require('./is-buffer');\n\n/**\n * Replaces every Buffer | ArrayBuffer in packet with a numbered placeholder.\n * Anything with blobs or files should be fed through removeBlobs before coming\n * here.\n *\n * @param {Object} packet - socket.io event packet\n * @return {Object} with deconstructed packet and list of buffers\n * @api public\n */\n\nexports.deconstructPacket = function(packet){\n  var buffers = [];\n  var packetData = packet.data;\n\n  function _deconstructPacket(data) {\n    if (!data) return data;\n\n    if (isBuf(data)) {\n      var placeholder = { _placeholder: true, num: buffers.length };\n      buffers.push(data);\n      return placeholder;\n    } else if (isArray(data)) {\n      var newData = new Array(data.length);\n      for (var i = 0; i < data.length; i++) {\n        newData[i] = _deconstructPacket(data[i]);\n      }\n      return newData;\n    } else if ('object' == typeof data && !(data instanceof Date)) {\n      var newData = {};\n      for (var key in data) {\n        newData[key] = _deconstructPacket(data[key]);\n      }\n      return newData;\n    }\n    return data;\n  }\n\n  var pack = packet;\n  pack.data = _deconstructPacket(packetData);\n  pack.attachments = buffers.length; // number of binary 'attachments'\n  return {packet: pack, buffers: buffers};\n};\n\n/**\n * Reconstructs a binary packet from its placeholder packet and buffers\n *\n * @param {Object} packet - event packet with placeholders\n * @param {Array} buffers - binary buffers to put in placeholder positions\n * @return {Object} reconstructed packet\n * @api public\n */\n\nexports.reconstructPacket = function(packet, buffers) {\n  var curPlaceHolder = 0;\n\n  function _reconstructPacket(data) {\n    if (data && data._placeholder) {\n      var buf = buffers[data.num]; // appropriate buffer (should be natural order anyway)\n      return buf;\n    } else if (isArray(data)) {\n      for (var i = 0; i < data.length; i++) {\n        data[i] = _reconstructPacket(data[i]);\n      }\n      return data;\n    } else if (data && 'object' == typeof data) {\n      for (var key in data) {\n        data[key] = _reconstructPacket(data[key]);\n      }\n      return data;\n    }\n    return data;\n  }\n\n  packet.data = _reconstructPacket(packet.data);\n  packet.attachments = undefined; // no longer useful\n  return packet;\n};\n\n/**\n * Asynchronously removes Blobs or Files from data via\n * FileReader's readAsArrayBuffer method. Used before encoding\n * data as msgpack. Calls callback with the blobless data.\n *\n * @param {Object} data\n * @param {Function} callback\n * @api private\n */\n\nexports.removeBlobs = function(data, callback) {\n  function _removeBlobs(obj, curKey, containingObject) {\n    if (!obj) return obj;\n\n    // convert any blob\n    if ((global.Blob && obj instanceof Blob) ||\n        (global.File && obj instanceof File)) {\n      pendingBlobs++;\n\n      // async filereader\n      var fileReader = new FileReader();\n      fileReader.onload = function() { // this.result == arraybuffer\n        if (containingObject) {\n          containingObject[curKey] = this.result;\n        }\n        else {\n          bloblessData = this.result;\n        }\n\n        // if nothing pending its callback time\n        if(! --pendingBlobs) {\n          callback(bloblessData);\n        }\n      };\n\n      fileReader.readAsArrayBuffer(obj); // blob -> arraybuffer\n    } else if (isArray(obj)) { // handle array\n      for (var i = 0; i < obj.length; i++) {\n        _removeBlobs(obj[i], i, obj);\n      }\n    } else if (obj && 'object' == typeof obj && !isBuf(obj)) { // and object\n      for (var key in obj) {\n        _removeBlobs(obj[key], key, obj);\n      }\n    }\n  }\n\n  var pendingBlobs = 0;\n  var bloblessData = data;\n  _removeBlobs(bloblessData);\n  if (!pendingBlobs) {\n    callback(bloblessData);\n  }\n};\n","\n/**\n * Module dependencies.\n */\n\nvar debug = require('debug')('socket.io-parser');\nvar json = require('json3');\nvar isArray = require('isarray');\nvar Emitter = require('component-emitter');\nvar binary = require('./binary');\nvar isBuf = require('./is-buffer');\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nexports.protocol = 4;\n\n/**\n * Packet types.\n *\n * @api public\n */\n\nexports.types = [\n  'CONNECT',\n  'DISCONNECT',\n  'EVENT',\n  'ACK',\n  'ERROR',\n  'BINARY_EVENT',\n  'BINARY_ACK'\n];\n\n/**\n * Packet type `connect`.\n *\n * @api public\n */\n\nexports.CONNECT = 0;\n\n/**\n * Packet type `disconnect`.\n *\n * @api public\n */\n\nexports.DISCONNECT = 1;\n\n/**\n * Packet type `event`.\n *\n * @api public\n */\n\nexports.EVENT = 2;\n\n/**\n * Packet type `ack`.\n *\n * @api public\n */\n\nexports.ACK = 3;\n\n/**\n * Packet type `error`.\n *\n * @api public\n */\n\nexports.ERROR = 4;\n\n/**\n * Packet type 'binary event'\n *\n * @api public\n */\n\nexports.BINARY_EVENT = 5;\n\n/**\n * Packet type `binary ack`. For acks with binary arguments.\n *\n * @api public\n */\n\nexports.BINARY_ACK = 6;\n\n/**\n * Encoder constructor.\n *\n * @api public\n */\n\nexports.Encoder = Encoder;\n\n/**\n * Decoder constructor.\n *\n * @api public\n */\n\nexports.Decoder = Decoder;\n\n/**\n * A socket.io Encoder instance\n *\n * @api public\n */\n\nfunction Encoder() {}\n\n/**\n * Encode a packet as a single string if non-binary, or as a\n * buffer sequence, depending on packet type.\n *\n * @param {Object} obj - packet object\n * @param {Function} callback - function to handle encodings (likely engine.write)\n * @return Calls callback with Array of encodings\n * @api public\n */\n\nEncoder.prototype.encode = function(obj, callback){\n  debug('encoding packet %j', obj);\n\n  if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {\n    encodeAsBinary(obj, callback);\n  }\n  else {\n    var encoding = encodeAsString(obj);\n    callback([encoding]);\n  }\n};\n\n/**\n * Encode packet as string.\n *\n * @param {Object} packet\n * @return {String} encoded\n * @api private\n */\n\nfunction encodeAsString(obj) {\n  var str = '';\n  var nsp = false;\n\n  // first is type\n  str += obj.type;\n\n  // attachments if we have them\n  if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {\n    str += obj.attachments;\n    str += '-';\n  }\n\n  // if we have a namespace other than `/`\n  // we append it followed by a comma `,`\n  if (obj.nsp && '/' != obj.nsp) {\n    nsp = true;\n    str += obj.nsp;\n  }\n\n  // immediately followed by the id\n  if (null != obj.id) {\n    if (nsp) {\n      str += ',';\n      nsp = false;\n    }\n    str += obj.id;\n  }\n\n  // json data\n  if (null != obj.data) {\n    if (nsp) str += ',';\n    str += json.stringify(obj.data);\n  }\n\n  debug('encoded %j as %s', obj, str);\n  return str;\n}\n\n/**\n * Encode packet as 'buffer sequence' by removing blobs, and\n * deconstructing packet into object with placeholders and\n * a list of buffers.\n *\n * @param {Object} packet\n * @return {Buffer} encoded\n * @api private\n */\n\nfunction encodeAsBinary(obj, callback) {\n\n  function writeEncoding(bloblessData) {\n    var deconstruction = binary.deconstructPacket(bloblessData);\n    var pack = encodeAsString(deconstruction.packet);\n    var buffers = deconstruction.buffers;\n\n    buffers.unshift(pack); // add packet info to beginning of data list\n    callback(buffers); // write all the buffers\n  }\n\n  binary.removeBlobs(obj, writeEncoding);\n}\n\n/**\n * A socket.io Decoder instance\n *\n * @return {Object} decoder\n * @api public\n */\n\nfunction Decoder() {\n  this.reconstructor = null;\n}\n\n/**\n * Mix in `Emitter` with Decoder.\n */\n\nEmitter(Decoder.prototype);\n\n/**\n * Decodes an ecoded packet string into packet JSON.\n *\n * @param {String} obj - encoded packet\n * @return {Object} packet\n * @api public\n */\n\nDecoder.prototype.add = function(obj) {\n  var packet;\n  if ('string' == typeof obj) {\n    packet = decodeString(obj);\n    if (exports.BINARY_EVENT == packet.type || exports.BINARY_ACK == packet.type) { // binary packet's json\n      this.reconstructor = new BinaryReconstructor(packet);\n\n      // no attachments, labeled binary but no binary data to follow\n      if (this.reconstructor.reconPack.attachments === 0) {\n        this.emit('decoded', packet);\n      }\n    } else { // non-binary full packet\n      this.emit('decoded', packet);\n    }\n  }\n  else if (isBuf(obj) || obj.base64) { // raw binary data\n    if (!this.reconstructor) {\n      throw new Error('got binary data when not reconstructing a packet');\n    } else {\n      packet = this.reconstructor.takeBinaryData(obj);\n      if (packet) { // received final buffer\n        this.reconstructor = null;\n        this.emit('decoded', packet);\n      }\n    }\n  }\n  else {\n    throw new Error('Unknown type: ' + obj);\n  }\n};\n\n/**\n * Decode a packet String (JSON data)\n *\n * @param {String} str\n * @return {Object} packet\n * @api private\n */\n\nfunction decodeString(str) {\n  var p = {};\n  var i = 0;\n\n  // look up type\n  p.type = Number(str.charAt(0));\n  if (null == exports.types[p.type]) return error();\n\n  // look up attachments if type binary\n  if (exports.BINARY_EVENT == p.type || exports.BINARY_ACK == p.type) {\n    var buf = '';\n    while (str.charAt(++i) != '-') {\n      buf += str.charAt(i);\n      if (i == str.length) break;\n    }\n    if (buf != Number(buf) || str.charAt(i) != '-') {\n      throw new Error('Illegal attachments');\n    }\n    p.attachments = Number(buf);\n  }\n\n  // look up namespace (if any)\n  if ('/' == str.charAt(i + 1)) {\n    p.nsp = '';\n    while (++i) {\n      var c = str.charAt(i);\n      if (',' == c) break;\n      p.nsp += c;\n      if (i == str.length) break;\n    }\n  } else {\n    p.nsp = '/';\n  }\n\n  // look up id\n  var next = str.charAt(i + 1);\n  if ('' !== next && Number(next) == next) {\n    p.id = '';\n    while (++i) {\n      var c = str.charAt(i);\n      if (null == c || Number(c) != c) {\n        --i;\n        break;\n      }\n      p.id += str.charAt(i);\n      if (i == str.length) break;\n    }\n    p.id = Number(p.id);\n  }\n\n  // look up json data\n  if (str.charAt(++i)) {\n    try {\n      p.data = json.parse(str.substr(i));\n    } catch(e){\n      return error();\n    }\n  }\n\n  debug('decoded %s as %j', str, p);\n  return p;\n}\n\n/**\n * Deallocates a parser's resources\n *\n * @api public\n */\n\nDecoder.prototype.destroy = function() {\n  if (this.reconstructor) {\n    this.reconstructor.finishedReconstruction();\n  }\n};\n\n/**\n * A manager of a binary event's 'buffer sequence'. Should\n * be constructed whenever a packet of type BINARY_EVENT is\n * decoded.\n *\n * @param {Object} packet\n * @return {BinaryReconstructor} initialized reconstructor\n * @api private\n */\n\nfunction BinaryReconstructor(packet) {\n  this.reconPack = packet;\n  this.buffers = [];\n}\n\n/**\n * Method to be called when binary data received from connection\n * after a BINARY_EVENT packet.\n *\n * @param {Buffer | ArrayBuffer} binData - the raw binary data received\n * @return {null | Object} returns null if more binary data is expected or\n *   a reconstructed packet object if all buffers have been received.\n * @api private\n */\n\nBinaryReconstructor.prototype.takeBinaryData = function(binData) {\n  this.buffers.push(binData);\n  if (this.buffers.length == this.reconPack.attachments) { // done with buffer list\n    var packet = binary.reconstructPacket(this.reconPack, this.buffers);\n    this.finishedReconstruction();\n    return packet;\n  }\n  return null;\n};\n\n/**\n * Cleans up binary packet reconstruction variables.\n *\n * @api private\n */\n\nBinaryReconstructor.prototype.finishedReconstruction = function() {\n  this.reconPack = null;\n  this.buffers = [];\n};\n\nfunction error(data){\n  return {\n    type: exports.ERROR,\n    data: 'parser error'\n  };\n}\n","\nmodule.exports = isBuf;\n\n/**\n * Returns true if obj is a buffer or an arraybuffer.\n *\n * @api private\n */\n\nfunction isBuf(obj) {\n  return (global.Buffer && global.Buffer.isBuffer(obj)) ||\n         (global.ArrayBuffer && obj instanceof ArrayBuffer);\n}\n","/*! JSON v3.3.2 | http://bestiejs.github.io/json3 | Copyright 2012-2014, Kit Cambridge | http://kit.mit-license.org */\n;(function () {\n  // Detect the `define` function exposed by asynchronous module loaders. The\n  // strict `define` check is necessary for compatibility with `r.js`.\n  var isLoader = typeof define === \"function\" && define.amd;\n\n  // A set of types used to distinguish objects from primitives.\n  var objectTypes = {\n    \"function\": true,\n    \"object\": true\n  };\n\n  // Detect the `exports` object exposed by CommonJS implementations.\n  var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;\n\n  // Use the `global` object exposed by Node (including Browserify via\n  // `insert-module-globals`), Narwhal, and Ringo as the default context,\n  // and the `window` object in browsers. Rhino exports a `global` function\n  // instead.\n  var root = objectTypes[typeof window] && window || this,\n      freeGlobal = freeExports && objectTypes[typeof module] && module && !module.nodeType && typeof global == \"object\" && global;\n\n  if (freeGlobal && (freeGlobal[\"global\"] === freeGlobal || freeGlobal[\"window\"] === freeGlobal || freeGlobal[\"self\"] === freeGlobal)) {\n    root = freeGlobal;\n  }\n\n  // Public: Initializes JSON 3 using the given `context` object, attaching the\n  // `stringify` and `parse` functions to the specified `exports` object.\n  function runInContext(context, exports) {\n    context || (context = root[\"Object\"]());\n    exports || (exports = root[\"Object\"]());\n\n    // Native constructor aliases.\n    var Number = context[\"Number\"] || root[\"Number\"],\n        String = context[\"String\"] || root[\"String\"],\n        Object = context[\"Object\"] || root[\"Object\"],\n        Date = context[\"Date\"] || root[\"Date\"],\n        SyntaxError = context[\"SyntaxError\"] || root[\"SyntaxError\"],\n        TypeError = context[\"TypeError\"] || root[\"TypeError\"],\n        Math = context[\"Math\"] || root[\"Math\"],\n        nativeJSON = context[\"JSON\"] || root[\"JSON\"];\n\n    // Delegate to the native `stringify` and `parse` implementations.\n    if (typeof nativeJSON == \"object\" && nativeJSON) {\n      exports.stringify = nativeJSON.stringify;\n      exports.parse = nativeJSON.parse;\n    }\n\n    // Convenience aliases.\n    var objectProto = Object.prototype,\n        getClass = objectProto.toString,\n        isProperty, forEach, undef;\n\n    // Test the `Date#getUTC*` methods. Based on work by @Yaffle.\n    var isExtended = new Date(-3509827334573292);\n    try {\n      // The `getUTCFullYear`, `Month`, and `Date` methods return nonsensical\n      // results for certain dates in Opera >= 10.53.\n      isExtended = isExtended.getUTCFullYear() == -109252 && isExtended.getUTCMonth() === 0 && isExtended.getUTCDate() === 1 &&\n        // Safari < 2.0.2 stores the internal millisecond time value correctly,\n        // but clips the values returned by the date methods to the range of\n        // signed 32-bit integers ([-2 ** 31, 2 ** 31 - 1]).\n        isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708;\n    } catch (exception) {}\n\n    // Internal: Determines whether the native `JSON.stringify` and `parse`\n    // implementations are spec-compliant. Based on work by Ken Snyder.\n    function has(name) {\n      if (has[name] !== undef) {\n        // Return cached feature test result.\n        return has[name];\n      }\n      var isSupported;\n      if (name == \"bug-string-char-index\") {\n        // IE <= 7 doesn't support accessing string characters using square\n        // bracket notation. IE 8 only supports this for primitives.\n        isSupported = \"a\"[0] != \"a\";\n      } else if (name == \"json\") {\n        // Indicates whether both `JSON.stringify` and `JSON.parse` are\n        // supported.\n        isSupported = has(\"json-stringify\") && has(\"json-parse\");\n      } else {\n        var value, serialized = '{\"a\":[1,true,false,null,\"\\\\u0000\\\\b\\\\n\\\\f\\\\r\\\\t\"]}';\n        // Test `JSON.stringify`.\n        if (name == \"json-stringify\") {\n          var stringify = exports.stringify, stringifySupported = typeof stringify == \"function\" && isExtended;\n          if (stringifySupported) {\n            // A test function object with a custom `toJSON` method.\n            (value = function () {\n              return 1;\n            }).toJSON = value;\n            try {\n              stringifySupported =\n                // Firefox 3.1b1 and b2 serialize string, number, and boolean\n                // primitives as object literals.\n                stringify(0) === \"0\" &&\n                // FF 3.1b1, b2, and JSON 2 serialize wrapped primitives as object\n                // literals.\n                stringify(new Number()) === \"0\" &&\n                stringify(new String()) == '\"\"' &&\n                // FF 3.1b1, 2 throw an error if the value is `null`, `undefined`, or\n                // does not define a canonical JSON representation (this applies to\n                // objects with `toJSON` properties as well, *unless* they are nested\n                // within an object or array).\n                stringify(getClass) === undef &&\n                // IE 8 serializes `undefined` as `\"undefined\"`. Safari <= 5.1.7 and\n                // FF 3.1b3 pass this test.\n                stringify(undef) === undef &&\n                // Safari <= 5.1.7 and FF 3.1b3 throw `Error`s and `TypeError`s,\n                // respectively, if the value is omitted entirely.\n                stringify() === undef &&\n                // FF 3.1b1, 2 throw an error if the given value is not a number,\n                // string, array, object, Boolean, or `null` literal. This applies to\n                // objects with custom `toJSON` methods as well, unless they are nested\n                // inside object or array literals. YUI 3.0.0b1 ignores custom `toJSON`\n                // methods entirely.\n                stringify(value) === \"1\" &&\n                stringify([value]) == \"[1]\" &&\n                // Prototype <= 1.6.1 serializes `[undefined]` as `\"[]\"` instead of\n                // `\"[null]\"`.\n                stringify([undef]) == \"[null]\" &&\n                // YUI 3.0.0b1 fails to serialize `null` literals.\n                stringify(null) == \"null\" &&\n                // FF 3.1b1, 2 halts serialization if an array contains a function:\n                // `[1, true, getClass, 1]` serializes as \"[1,true,],\". FF 3.1b3\n                // elides non-JSON values from objects and arrays, unless they\n                // define custom `toJSON` methods.\n                stringify([undef, getClass, null]) == \"[null,null,null]\" &&\n                // Simple serialization test. FF 3.1b1 uses Unicode escape sequences\n                // where character escape codes are expected (e.g., `\\b` => `\\u0008`).\n                stringify({ \"a\": [value, true, false, null, \"\\x00\\b\\n\\f\\r\\t\"] }) == serialized &&\n                // FF 3.1b1 and b2 ignore the `filter` and `width` arguments.\n                stringify(null, value) === \"1\" &&\n                stringify([1, 2], null, 1) == \"[\\n 1,\\n 2\\n]\" &&\n                // JSON 2, Prototype <= 1.7, and older WebKit builds incorrectly\n                // serialize extended years.\n                stringify(new Date(-8.64e15)) == '\"-271821-04-20T00:00:00.000Z\"' &&\n                // The milliseconds are optional in ES 5, but required in 5.1.\n                stringify(new Date(8.64e15)) == '\"+275760-09-13T00:00:00.000Z\"' &&\n                // Firefox <= 11.0 incorrectly serializes years prior to 0 as negative\n                // four-digit years instead of six-digit years. Credits: @Yaffle.\n                stringify(new Date(-621987552e5)) == '\"-000001-01-01T00:00:00.000Z\"' &&\n                // Safari <= 5.1.5 and Opera >= 10.53 incorrectly serialize millisecond\n                // values less than 1000. Credits: @Yaffle.\n                stringify(new Date(-1)) == '\"1969-12-31T23:59:59.999Z\"';\n            } catch (exception) {\n              stringifySupported = false;\n            }\n          }\n          isSupported = stringifySupported;\n        }\n        // Test `JSON.parse`.\n        if (name == \"json-parse\") {\n          var parse = exports.parse;\n          if (typeof parse == \"function\") {\n            try {\n              // FF 3.1b1, b2 will throw an exception if a bare literal is provided.\n              // Conforming implementations should also coerce the initial argument to\n              // a string prior to parsing.\n              if (parse(\"0\") === 0 && !parse(false)) {\n                // Simple parsing test.\n                value = parse(serialized);\n                var parseSupported = value[\"a\"].length == 5 && value[\"a\"][0] === 1;\n                if (parseSupported) {\n                  try {\n                    // Safari <= 5.1.2 and FF 3.1b1 allow unescaped tabs in strings.\n                    parseSupported = !parse('\"\\t\"');\n                  } catch (exception) {}\n                  if (parseSupported) {\n                    try {\n                      // FF 4.0 and 4.0.1 allow leading `+` signs and leading\n                      // decimal points. FF 4.0, 4.0.1, and IE 9-10 also allow\n                      // certain octal literals.\n                      parseSupported = parse(\"01\") !== 1;\n                    } catch (exception) {}\n                  }\n                  if (parseSupported) {\n                    try {\n                      // FF 4.0, 4.0.1, and Rhino 1.7R3-R4 allow trailing decimal\n                      // points. These environments, along with FF 3.1b1 and 2,\n                      // also allow trailing commas in JSON objects and arrays.\n                      parseSupported = parse(\"1.\") !== 1;\n                    } catch (exception) {}\n                  }\n                }\n              }\n            } catch (exception) {\n              parseSupported = false;\n            }\n          }\n          isSupported = parseSupported;\n        }\n      }\n      return has[name] = !!isSupported;\n    }\n\n    if (!has(\"json\")) {\n      // Common `[[Class]]` name aliases.\n      var functionClass = \"[object Function]\",\n          dateClass = \"[object Date]\",\n          numberClass = \"[object Number]\",\n          stringClass = \"[object String]\",\n          arrayClass = \"[object Array]\",\n          booleanClass = \"[object Boolean]\";\n\n      // Detect incomplete support for accessing string characters by index.\n      var charIndexBuggy = has(\"bug-string-char-index\");\n\n      // Define additional utility methods if the `Date` methods are buggy.\n      if (!isExtended) {\n        var floor = Math.floor;\n        // A mapping between the months of the year and the number of days between\n        // January 1st and the first of the respective month.\n        var Months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];\n        // Internal: Calculates the number of days between the Unix epoch and the\n        // first day of the given month.\n        var getDay = function (year, month) {\n          return Months[month] + 365 * (year - 1970) + floor((year - 1969 + (month = +(month > 1))) / 4) - floor((year - 1901 + month) / 100) + floor((year - 1601 + month) / 400);\n        };\n      }\n\n      // Internal: Determines if a property is a direct property of the given\n      // object. Delegates to the native `Object#hasOwnProperty` method.\n      if (!(isProperty = objectProto.hasOwnProperty)) {\n        isProperty = function (property) {\n          var members = {}, constructor;\n          if ((members.__proto__ = null, members.__proto__ = {\n            // The *proto* property cannot be set multiple times in recent\n            // versions of Firefox and SeaMonkey.\n            \"toString\": 1\n          }, members).toString != getClass) {\n            // Safari <= 2.0.3 doesn't implement `Object#hasOwnProperty`, but\n            // supports the mutable *proto* property.\n            isProperty = function (property) {\n              // Capture and break the object's prototype chain (see section 8.6.2\n              // of the ES 5.1 spec). The parenthesized expression prevents an\n              // unsafe transformation by the Closure Compiler.\n              var original = this.__proto__, result = property in (this.__proto__ = null, this);\n              // Restore the original prototype chain.\n              this.__proto__ = original;\n              return result;\n            };\n          } else {\n            // Capture a reference to the top-level `Object` constructor.\n            constructor = members.constructor;\n            // Use the `constructor` property to simulate `Object#hasOwnProperty` in\n            // other environments.\n            isProperty = function (property) {\n              var parent = (this.constructor || constructor).prototype;\n              return property in this && !(property in parent && this[property] === parent[property]);\n            };\n          }\n          members = null;\n          return isProperty.call(this, property);\n        };\n      }\n\n      // Internal: Normalizes the `for...in` iteration algorithm across\n      // environments. Each enumerated key is yielded to a `callback` function.\n      forEach = function (object, callback) {\n        var size = 0, Properties, members, property;\n\n        // Tests for bugs in the current environment's `for...in` algorithm. The\n        // `valueOf` property inherits the non-enumerable flag from\n        // `Object.prototype` in older versions of IE, Netscape, and Mozilla.\n        (Properties = function () {\n          this.valueOf = 0;\n        }).prototype.valueOf = 0;\n\n        // Iterate over a new instance of the `Properties` class.\n        members = new Properties();\n        for (property in members) {\n          // Ignore all properties inherited from `Object.prototype`.\n          if (isProperty.call(members, property)) {\n            size++;\n          }\n        }\n        Properties = members = null;\n\n        // Normalize the iteration algorithm.\n        if (!size) {\n          // A list of non-enumerable properties inherited from `Object.prototype`.\n          members = [\"valueOf\", \"toString\", \"toLocaleString\", \"propertyIsEnumerable\", \"isPrototypeOf\", \"hasOwnProperty\", \"constructor\"];\n          // IE <= 8, Mozilla 1.0, and Netscape 6.2 ignore shadowed non-enumerable\n          // properties.\n          forEach = function (object, callback) {\n            var isFunction = getClass.call(object) == functionClass, property, length;\n            var hasProperty = !isFunction && typeof object.constructor != \"function\" && objectTypes[typeof object.hasOwnProperty] && object.hasOwnProperty || isProperty;\n            for (property in object) {\n              // Gecko <= 1.0 enumerates the `prototype` property of functions under\n              // certain conditions; IE does not.\n              if (!(isFunction && property == \"prototype\") && hasProperty.call(object, property)) {\n                callback(property);\n              }\n            }\n            // Manually invoke the callback for each non-enumerable property.\n            for (length = members.length; property = members[--length]; hasProperty.call(object, property) && callback(property));\n          };\n        } else if (size == 2) {\n          // Safari <= 2.0.4 enumerates shadowed properties twice.\n          forEach = function (object, callback) {\n            // Create a set of iterated properties.\n            var members = {}, isFunction = getClass.call(object) == functionClass, property;\n            for (property in object) {\n              // Store each property name to prevent double enumeration. The\n              // `prototype` property of functions is not enumerated due to cross-\n              // environment inconsistencies.\n              if (!(isFunction && property == \"prototype\") && !isProperty.call(members, property) && (members[property] = 1) && isProperty.call(object, property)) {\n                callback(property);\n              }\n            }\n          };\n        } else {\n          // No bugs detected; use the standard `for...in` algorithm.\n          forEach = function (object, callback) {\n            var isFunction = getClass.call(object) == functionClass, property, isConstructor;\n            for (property in object) {\n              if (!(isFunction && property == \"prototype\") && isProperty.call(object, property) && !(isConstructor = property === \"constructor\")) {\n                callback(property);\n              }\n            }\n            // Manually invoke the callback for the `constructor` property due to\n            // cross-environment inconsistencies.\n            if (isConstructor || isProperty.call(object, (property = \"constructor\"))) {\n              callback(property);\n            }\n          };\n        }\n        return forEach(object, callback);\n      };\n\n      // Public: Serializes a JavaScript `value` as a JSON string. The optional\n      // `filter` argument may specify either a function that alters how object and\n      // array members are serialized, or an array of strings and numbers that\n      // indicates which properties should be serialized. The optional `width`\n      // argument may be either a string or number that specifies the indentation\n      // level of the output.\n      if (!has(\"json-stringify\")) {\n        // Internal: A map of control characters and their escaped equivalents.\n        var Escapes = {\n          92: \"\\\\\\\\\",\n          34: '\\\\\"',\n          8: \"\\\\b\",\n          12: \"\\\\f\",\n          10: \"\\\\n\",\n          13: \"\\\\r\",\n          9: \"\\\\t\"\n        };\n\n        // Internal: Converts `value` into a zero-padded string such that its\n        // length is at least equal to `width`. The `width` must be <= 6.\n        var leadingZeroes = \"000000\";\n        var toPaddedString = function (width, value) {\n          // The `|| 0` expression is necessary to work around a bug in\n          // Opera <= 7.54u2 where `0 == -0`, but `String(-0) !== \"0\"`.\n          return (leadingZeroes + (value || 0)).slice(-width);\n        };\n\n        // Internal: Double-quotes a string `value`, replacing all ASCII control\n        // characters (characters with code unit values between 0 and 31) with\n        // their escaped equivalents. This is an implementation of the\n        // `Quote(value)` operation defined in ES 5.1 section 15.12.3.\n        var unicodePrefix = \"\\\\u00\";\n        var quote = function (value) {\n          var result = '\"', index = 0, length = value.length, useCharIndex = !charIndexBuggy || length > 10;\n          var symbols = useCharIndex && (charIndexBuggy ? value.split(\"\") : value);\n          for (; index < length; index++) {\n            var charCode = value.charCodeAt(index);\n            // If the character is a control character, append its Unicode or\n            // shorthand escape sequence; otherwise, append the character as-is.\n            switch (charCode) {\n              case 8: case 9: case 10: case 12: case 13: case 34: case 92:\n                result += Escapes[charCode];\n                break;\n              default:\n                if (charCode < 32) {\n                  result += unicodePrefix + toPaddedString(2, charCode.toString(16));\n                  break;\n                }\n                result += useCharIndex ? symbols[index] : value.charAt(index);\n            }\n          }\n          return result + '\"';\n        };\n\n        // Internal: Recursively serializes an object. Implements the\n        // `Str(key, holder)`, `JO(value)`, and `JA(value)` operations.\n        var serialize = function (property, object, callback, properties, whitespace, indentation, stack) {\n          var value, className, year, month, date, time, hours, minutes, seconds, milliseconds, results, element, index, length, prefix, result;\n          try {\n            // Necessary for host object support.\n            value = object[property];\n          } catch (exception) {}\n          if (typeof value == \"object\" && value) {\n            className = getClass.call(value);\n            if (className == dateClass && !isProperty.call(value, \"toJSON\")) {\n              if (value > -1 / 0 && value < 1 / 0) {\n                // Dates are serialized according to the `Date#toJSON` method\n                // specified in ES 5.1 section 15.9.5.44. See section 15.9.1.15\n                // for the ISO 8601 date time string format.\n                if (getDay) {\n                  // Manually compute the year, month, date, hours, minutes,\n                  // seconds, and milliseconds if the `getUTC*` methods are\n                  // buggy. Adapted from @Yaffle's `date-shim` project.\n                  date = floor(value / 864e5);\n                  for (year = floor(date / 365.2425) + 1970 - 1; getDay(year + 1, 0) <= date; year++);\n                  for (month = floor((date - getDay(year, 0)) / 30.42); getDay(year, month + 1) <= date; month++);\n                  date = 1 + date - getDay(year, month);\n                  // The `time` value specifies the time within the day (see ES\n                  // 5.1 section 15.9.1.2). The formula `(A % B + B) % B` is used\n                  // to compute `A modulo B`, as the `%` operator does not\n                  // correspond to the `modulo` operation for negative numbers.\n                  time = (value % 864e5 + 864e5) % 864e5;\n                  // The hours, minutes, seconds, and milliseconds are obtained by\n                  // decomposing the time within the day. See section 15.9.1.10.\n                  hours = floor(time / 36e5) % 24;\n                  minutes = floor(time / 6e4) % 60;\n                  seconds = floor(time / 1e3) % 60;\n                  milliseconds = time % 1e3;\n                } else {\n                  year = value.getUTCFullYear();\n                  month = value.getUTCMonth();\n                  date = value.getUTCDate();\n                  hours = value.getUTCHours();\n                  minutes = value.getUTCMinutes();\n                  seconds = value.getUTCSeconds();\n                  milliseconds = value.getUTCMilliseconds();\n                }\n                // Serialize extended years correctly.\n                value = (year <= 0 || year >= 1e4 ? (year < 0 ? \"-\" : \"+\") + toPaddedString(6, year < 0 ? -year : year) : toPaddedString(4, year)) +\n                  \"-\" + toPaddedString(2, month + 1) + \"-\" + toPaddedString(2, date) +\n                  // Months, dates, hours, minutes, and seconds should have two\n                  // digits; milliseconds should have three.\n                  \"T\" + toPaddedString(2, hours) + \":\" + toPaddedString(2, minutes) + \":\" + toPaddedString(2, seconds) +\n                  // Milliseconds are optional in ES 5.0, but required in 5.1.\n                  \".\" + toPaddedString(3, milliseconds) + \"Z\";\n              } else {\n                value = null;\n              }\n            } else if (typeof value.toJSON == \"function\" && ((className != numberClass && className != stringClass && className != arrayClass) || isProperty.call(value, \"toJSON\"))) {\n              // Prototype <= 1.6.1 adds non-standard `toJSON` methods to the\n              // `Number`, `String`, `Date`, and `Array` prototypes. JSON 3\n              // ignores all `toJSON` methods on these objects unless they are\n              // defined directly on an instance.\n              value = value.toJSON(property);\n            }\n          }\n          if (callback) {\n            // If a replacement function was provided, call it to obtain the value\n            // for serialization.\n            value = callback.call(object, property, value);\n          }\n          if (value === null) {\n            return \"null\";\n          }\n          className = getClass.call(value);\n          if (className == booleanClass) {\n            // Booleans are represented literally.\n            return \"\" + value;\n          } else if (className == numberClass) {\n            // JSON numbers must be finite. `Infinity` and `NaN` are serialized as\n            // `\"null\"`.\n            return value > -1 / 0 && value < 1 / 0 ? \"\" + value : \"null\";\n          } else if (className == stringClass) {\n            // Strings are double-quoted and escaped.\n            return quote(\"\" + value);\n          }\n          // Recursively serialize objects and arrays.\n          if (typeof value == \"object\") {\n            // Check for cyclic structures. This is a linear search; performance\n            // is inversely proportional to the number of unique nested objects.\n            for (length = stack.length; length--;) {\n              if (stack[length] === value) {\n                // Cyclic structures cannot be serialized by `JSON.stringify`.\n                throw TypeError();\n              }\n            }\n            // Add the object to the stack of traversed objects.\n            stack.push(value);\n            results = [];\n            // Save the current indentation level and indent one additional level.\n            prefix = indentation;\n            indentation += whitespace;\n            if (className == arrayClass) {\n              // Recursively serialize array elements.\n              for (index = 0, length = value.length; index < length; index++) {\n                element = serialize(index, value, callback, properties, whitespace, indentation, stack);\n                results.push(element === undef ? \"null\" : element);\n              }\n              result = results.length ? (whitespace ? \"[\\n\" + indentation + results.join(\",\\n\" + indentation) + \"\\n\" + prefix + \"]\" : (\"[\" + results.join(\",\") + \"]\")) : \"[]\";\n            } else {\n              // Recursively serialize object members. Members are selected from\n              // either a user-specified list of property names, or the object\n              // itself.\n              forEach(properties || value, function (property) {\n                var element = serialize(property, value, callback, properties, whitespace, indentation, stack);\n                if (element !== undef) {\n                  // According to ES 5.1 section 15.12.3: \"If `gap` {whitespace}\n                  // is not the empty string, let `member` {quote(property) + \":\"}\n                  // be the concatenation of `member` and the `space` character.\"\n                  // The \"`space` character\" refers to the literal space\n                  // character, not the `space` {width} argument provided to\n                  // `JSON.stringify`.\n                  results.push(quote(property) + \":\" + (whitespace ? \" \" : \"\") + element);\n                }\n              });\n              result = results.length ? (whitespace ? \"{\\n\" + indentation + results.join(\",\\n\" + indentation) + \"\\n\" + prefix + \"}\" : (\"{\" + results.join(\",\") + \"}\")) : \"{}\";\n            }\n            // Remove the object from the traversed object stack.\n            stack.pop();\n            return result;\n          }\n        };\n\n        // Public: `JSON.stringify`. See ES 5.1 section 15.12.3.\n        exports.stringify = function (source, filter, width) {\n          var whitespace, callback, properties, className;\n          if (objectTypes[typeof filter] && filter) {\n            if ((className = getClass.call(filter)) == functionClass) {\n              callback = filter;\n            } else if (className == arrayClass) {\n              // Convert the property names array into a makeshift set.\n              properties = {};\n              for (var index = 0, length = filter.length, value; index < length; value = filter[index++], ((className = getClass.call(value)), className == stringClass || className == numberClass) && (properties[value] = 1));\n            }\n          }\n          if (width) {\n            if ((className = getClass.call(width)) == numberClass) {\n              // Convert the `width` to an integer and create a string containing\n              // `width` number of space characters.\n              if ((width -= width % 1) > 0) {\n                for (whitespace = \"\", width > 10 && (width = 10); whitespace.length < width; whitespace += \" \");\n              }\n            } else if (className == stringClass) {\n              whitespace = width.length <= 10 ? width : width.slice(0, 10);\n            }\n          }\n          // Opera <= 7.54u2 discards the values associated with empty string keys\n          // (`\"\"`) only if they are used directly within an object member list\n          // (e.g., `!(\"\" in { \"\": 1})`).\n          return serialize(\"\", (value = {}, value[\"\"] = source, value), callback, properties, whitespace, \"\", []);\n        };\n      }\n\n      // Public: Parses a JSON source string.\n      if (!has(\"json-parse\")) {\n        var fromCharCode = String.fromCharCode;\n\n        // Internal: A map of escaped control characters and their unescaped\n        // equivalents.\n        var Unescapes = {\n          92: \"\\\\\",\n          34: '\"',\n          47: \"/\",\n          98: \"\\b\",\n          116: \"\\t\",\n          110: \"\\n\",\n          102: \"\\f\",\n          114: \"\\r\"\n        };\n\n        // Internal: Stores the parser state.\n        var Index, Source;\n\n        // Internal: Resets the parser state and throws a `SyntaxError`.\n        var abort = function () {\n          Index = Source = null;\n          throw SyntaxError();\n        };\n\n        // Internal: Returns the next token, or `\"$\"` if the parser has reached\n        // the end of the source string. A token may be a string, number, `null`\n        // literal, or Boolean literal.\n        var lex = function () {\n          var source = Source, length = source.length, value, begin, position, isSigned, charCode;\n          while (Index < length) {\n            charCode = source.charCodeAt(Index);\n            switch (charCode) {\n              case 9: case 10: case 13: case 32:\n                // Skip whitespace tokens, including tabs, carriage returns, line\n                // feeds, and space characters.\n                Index++;\n                break;\n              case 123: case 125: case 91: case 93: case 58: case 44:\n                // Parse a punctuator token (`{`, `}`, `[`, `]`, `:`, or `,`) at\n                // the current position.\n                value = charIndexBuggy ? source.charAt(Index) : source[Index];\n                Index++;\n                return value;\n              case 34:\n                // `\"` delimits a JSON string; advance to the next character and\n                // begin parsing the string. String tokens are prefixed with the\n                // sentinel `@` character to distinguish them from punctuators and\n                // end-of-string tokens.\n                for (value = \"@\", Index++; Index < length;) {\n                  charCode = source.charCodeAt(Index);\n                  if (charCode < 32) {\n                    // Unescaped ASCII control characters (those with a code unit\n                    // less than the space character) are not permitted.\n                    abort();\n                  } else if (charCode == 92) {\n                    // A reverse solidus (`\\`) marks the beginning of an escaped\n                    // control character (including `\"`, `\\`, and `/`) or Unicode\n                    // escape sequence.\n                    charCode = source.charCodeAt(++Index);\n                    switch (charCode) {\n                      case 92: case 34: case 47: case 98: case 116: case 110: case 102: case 114:\n                        // Revive escaped control characters.\n                        value += Unescapes[charCode];\n                        Index++;\n                        break;\n                      case 117:\n                        // `\\u` marks the beginning of a Unicode escape sequence.\n                        // Advance to the first character and validate the\n                        // four-digit code point.\n                        begin = ++Index;\n                        for (position = Index + 4; Index < position; Index++) {\n                          charCode = source.charCodeAt(Index);\n                          // A valid sequence comprises four hexdigits (case-\n                          // insensitive) that form a single hexadecimal value.\n                          if (!(charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70)) {\n                            // Invalid Unicode escape sequence.\n                            abort();\n                          }\n                        }\n                        // Revive the escaped character.\n                        value += fromCharCode(\"0x\" + source.slice(begin, Index));\n                        break;\n                      default:\n                        // Invalid escape sequence.\n                        abort();\n                    }\n                  } else {\n                    if (charCode == 34) {\n                      // An unescaped double-quote character marks the end of the\n                      // string.\n                      break;\n                    }\n                    charCode = source.charCodeAt(Index);\n                    begin = Index;\n                    // Optimize for the common case where a string is valid.\n                    while (charCode >= 32 && charCode != 92 && charCode != 34) {\n                      charCode = source.charCodeAt(++Index);\n                    }\n                    // Append the string as-is.\n                    value += source.slice(begin, Index);\n                  }\n                }\n                if (source.charCodeAt(Index) == 34) {\n                  // Advance to the next character and return the revived string.\n                  Index++;\n                  return value;\n                }\n                // Unterminated string.\n                abort();\n              default:\n                // Parse numbers and literals.\n                begin = Index;\n                // Advance past the negative sign, if one is specified.\n                if (charCode == 45) {\n                  isSigned = true;\n                  charCode = source.charCodeAt(++Index);\n                }\n                // Parse an integer or floating-point value.\n                if (charCode >= 48 && charCode <= 57) {\n                  // Leading zeroes are interpreted as octal literals.\n                  if (charCode == 48 && ((charCode = source.charCodeAt(Index + 1)), charCode >= 48 && charCode <= 57)) {\n                    // Illegal octal literal.\n                    abort();\n                  }\n                  isSigned = false;\n                  // Parse the integer component.\n                  for (; Index < length && ((charCode = source.charCodeAt(Index)), charCode >= 48 && charCode <= 57); Index++);\n                  // Floats cannot contain a leading decimal point; however, this\n                  // case is already accounted for by the parser.\n                  if (source.charCodeAt(Index) == 46) {\n                    position = ++Index;\n                    // Parse the decimal component.\n                    for (; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);\n                    if (position == Index) {\n                      // Illegal trailing decimal.\n                      abort();\n                    }\n                    Index = position;\n                  }\n                  // Parse exponents. The `e` denoting the exponent is\n                  // case-insensitive.\n                  charCode = source.charCodeAt(Index);\n                  if (charCode == 101 || charCode == 69) {\n                    charCode = source.charCodeAt(++Index);\n                    // Skip past the sign following the exponent, if one is\n                    // specified.\n                    if (charCode == 43 || charCode == 45) {\n                      Index++;\n                    }\n                    // Parse the exponential component.\n                    for (position = Index; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);\n                    if (position == Index) {\n                      // Illegal empty exponent.\n                      abort();\n                    }\n                    Index = position;\n                  }\n                  // Coerce the parsed value to a JavaScript number.\n                  return +source.slice(begin, Index);\n                }\n                // A negative sign may only precede numbers.\n                if (isSigned) {\n                  abort();\n                }\n                // `true`, `false`, and `null` literals.\n                if (source.slice(Index, Index + 4) == \"true\") {\n                  Index += 4;\n                  return true;\n                } else if (source.slice(Index, Index + 5) == \"false\") {\n                  Index += 5;\n                  return false;\n                } else if (source.slice(Index, Index + 4) == \"null\") {\n                  Index += 4;\n                  return null;\n                }\n                // Unrecognized token.\n                abort();\n            }\n          }\n          // Return the sentinel `$` character if the parser has reached the end\n          // of the source string.\n          return \"$\";\n        };\n\n        // Internal: Parses a JSON `value` token.\n        var get = function (value) {\n          var results, hasMembers;\n          if (value == \"$\") {\n            // Unexpected end of input.\n            abort();\n          }\n          if (typeof value == \"string\") {\n            if ((charIndexBuggy ? value.charAt(0) : value[0]) == \"@\") {\n              // Remove the sentinel `@` character.\n              return value.slice(1);\n            }\n            // Parse object and array literals.\n            if (value == \"[\") {\n              // Parses a JSON array, returning a new JavaScript array.\n              results = [];\n              for (;; hasMembers || (hasMembers = true)) {\n                value = lex();\n                // A closing square bracket marks the end of the array literal.\n                if (value == \"]\") {\n                  break;\n                }\n                // If the array literal contains elements, the current token\n                // should be a comma separating the previous element from the\n                // next.\n                if (hasMembers) {\n                  if (value == \",\") {\n                    value = lex();\n                    if (value == \"]\") {\n                      // Unexpected trailing `,` in array literal.\n                      abort();\n                    }\n                  } else {\n                    // A `,` must separate each array element.\n                    abort();\n                  }\n                }\n                // Elisions and leading commas are not permitted.\n                if (value == \",\") {\n                  abort();\n                }\n                results.push(get(value));\n              }\n              return results;\n            } else if (value == \"{\") {\n              // Parses a JSON object, returning a new JavaScript object.\n              results = {};\n              for (;; hasMembers || (hasMembers = true)) {\n                value = lex();\n                // A closing curly brace marks the end of the object literal.\n                if (value == \"}\") {\n                  break;\n                }\n                // If the object literal contains members, the current token\n                // should be a comma separator.\n                if (hasMembers) {\n                  if (value == \",\") {\n                    value = lex();\n                    if (value == \"}\") {\n                      // Unexpected trailing `,` in object literal.\n                      abort();\n                    }\n                  } else {\n                    // A `,` must separate each object member.\n                    abort();\n                  }\n                }\n                // Leading commas are not permitted, object property names must be\n                // double-quoted strings, and a `:` must separate each property\n                // name and value.\n                if (value == \",\" || typeof value != \"string\" || (charIndexBuggy ? value.charAt(0) : value[0]) != \"@\" || lex() != \":\") {\n                  abort();\n                }\n                results[value.slice(1)] = get(lex());\n              }\n              return results;\n            }\n            // Unexpected token encountered.\n            abort();\n          }\n          return value;\n        };\n\n        // Internal: Updates a traversed object member.\n        var update = function (source, property, callback) {\n          var element = walk(source, property, callback);\n          if (element === undef) {\n            delete source[property];\n          } else {\n            source[property] = element;\n          }\n        };\n\n        // Internal: Recursively traverses a parsed JSON object, invoking the\n        // `callback` function for each value. This is an implementation of the\n        // `Walk(holder, name)` operation defined in ES 5.1 section 15.12.2.\n        var walk = function (source, property, callback) {\n          var value = source[property], length;\n          if (typeof value == \"object\" && value) {\n            // `forEach` can't be used to traverse an array in Opera <= 8.54\n            // because its `Object#hasOwnProperty` implementation returns `false`\n            // for array indices (e.g., `![1, 2, 3].hasOwnProperty(\"0\")`).\n            if (getClass.call(value) == arrayClass) {\n              for (length = value.length; length--;) {\n                update(value, length, callback);\n              }\n            } else {\n              forEach(value, function (property) {\n                update(value, property, callback);\n              });\n            }\n          }\n          return callback.call(source, property, value);\n        };\n\n        // Public: `JSON.parse`. See ES 5.1 section 15.12.2.\n        exports.parse = function (source, callback) {\n          var result, value;\n          Index = 0;\n          Source = \"\" + source;\n          result = get(lex());\n          // If a JSON string contains multiple tokens, it is invalid.\n          if (lex() != \"$\") {\n            abort();\n          }\n          // Reset the parser state.\n          Index = Source = null;\n          return callback && getClass.call(callback) == functionClass ? walk((value = {}, value[\"\"] = result, value), \"\", callback) : result;\n        };\n      }\n    }\n\n    exports[\"runInContext\"] = runInContext;\n    return exports;\n  }\n\n  if (freeExports && !isLoader) {\n    // Export for CommonJS environments.\n    runInContext(root, freeExports);\n  } else {\n    // Export for web browsers and JavaScript engines.\n    var nativeJSON = root.JSON,\n        previousJSON = root[\"JSON3\"],\n        isRestored = false;\n\n    var JSON3 = runInContext(root, (root[\"JSON3\"] = {\n      // Public: Restores the original value of the global `JSON` object and\n      // returns a reference to the `JSON3` object.\n      \"noConflict\": function () {\n        if (!isRestored) {\n          isRestored = true;\n          root.JSON = nativeJSON;\n          root[\"JSON3\"] = previousJSON;\n          nativeJSON = previousJSON = null;\n        }\n        return JSON3;\n      }\n    }));\n\n    root.JSON = {\n      \"parse\": JSON3.parse,\n      \"stringify\": JSON3.stringify\n    };\n  }\n\n  // Export for asynchronous module loaders.\n  if (isLoader) {\n    define(function () {\n      return JSON3;\n    });\n  }\n}).call(this);\n","module.exports = toArray\n\nfunction toArray(list, index) {\n    var array = []\n\n    index = index || 0\n\n    for (var i = index || 0; i < list.length; i++) {\n        array[i - index] = list[i]\n    }\n\n    return array\n}\n","/*! https://mths.be/utf8js v2.0.0 by @mathias */\n;(function(root) {\n\n\t// Detect free variables `exports`\n\tvar freeExports = typeof exports == 'object' && exports;\n\n\t// Detect free variable `module`\n\tvar freeModule = typeof module == 'object' && module &&\n\t\tmodule.exports == freeExports && module;\n\n\t// Detect free variable `global`, from Node.js or Browserified code,\n\t// and use it as `root`\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n\t\troot = freeGlobal;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar stringFromCharCode = String.fromCharCode;\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2decode(string) {\n\t\tvar output = [];\n\t\tvar counter = 0;\n\t\tvar length = string.length;\n\t\tvar value;\n\t\tvar extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t// Taken from https://mths.be/punycode\n\tfunction ucs2encode(array) {\n\t\tvar length = array.length;\n\t\tvar index = -1;\n\t\tvar value;\n\t\tvar output = '';\n\t\twhile (++index < length) {\n\t\t\tvalue = array[index];\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t}\n\t\treturn output;\n\t}\n\n\tfunction checkScalarValue(codePoint) {\n\t\tif (codePoint >= 0xD800 && codePoint <= 0xDFFF) {\n\t\t\tthrow Error(\n\t\t\t\t'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +\n\t\t\t\t' is not a scalar value'\n\t\t\t);\n\t\t}\n\t}\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction createByte(codePoint, shift) {\n\t\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n\t}\n\n\tfunction encodeCodePoint(codePoint) {\n\t\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\t\treturn stringFromCharCode(codePoint);\n\t\t}\n\t\tvar symbol = '';\n\t\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t\t}\n\t\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\t\tcheckScalarValue(codePoint);\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\t\tsymbol += createByte(codePoint, 12);\n\t\t\tsymbol += createByte(codePoint, 6);\n\t\t}\n\t\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\t\treturn symbol;\n\t}\n\n\tfunction utf8encode(string) {\n\t\tvar codePoints = ucs2decode(string);\n\t\tvar length = codePoints.length;\n\t\tvar index = -1;\n\t\tvar codePoint;\n\t\tvar byteString = '';\n\t\twhile (++index < length) {\n\t\t\tcodePoint = codePoints[index];\n\t\t\tbyteString += encodeCodePoint(codePoint);\n\t\t}\n\t\treturn byteString;\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tfunction readContinuationByte() {\n\t\tif (byteIndex >= byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\tif ((continuationByte & 0xC0) == 0x80) {\n\t\t\treturn continuationByte & 0x3F;\n\t\t}\n\n\t\t// If we end up here, it’s not a continuation byte\n\t\tthrow Error('Invalid continuation byte');\n\t}\n\n\tfunction decodeSymbol() {\n\t\tvar byte1;\n\t\tvar byte2;\n\t\tvar byte3;\n\t\tvar byte4;\n\t\tvar codePoint;\n\n\t\tif (byteIndex > byteCount) {\n\t\t\tthrow Error('Invalid byte index');\n\t\t}\n\n\t\tif (byteIndex == byteCount) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Read first byte\n\t\tbyte1 = byteArray[byteIndex] & 0xFF;\n\t\tbyteIndex++;\n\n\t\t// 1-byte sequence (no continuation bytes)\n\t\tif ((byte1 & 0x80) == 0) {\n\t\t\treturn byte1;\n\t\t}\n\n\t\t// 2-byte sequence\n\t\tif ((byte1 & 0xE0) == 0xC0) {\n\t\t\tvar byte2 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\t\tif (codePoint >= 0x80) {\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 3-byte sequence (may include unpaired surrogates)\n\t\tif ((byte1 & 0xF0) == 0xE0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\t\tif (codePoint >= 0x0800) {\n\t\t\t\tcheckScalarValue(codePoint);\n\t\t\t\treturn codePoint;\n\t\t\t} else {\n\t\t\t\tthrow Error('Invalid continuation byte');\n\t\t\t}\n\t\t}\n\n\t\t// 4-byte sequence\n\t\tif ((byte1 & 0xF8) == 0xF0) {\n\t\t\tbyte2 = readContinuationByte();\n\t\t\tbyte3 = readContinuationByte();\n\t\t\tbyte4 = readContinuationByte();\n\t\t\tcodePoint = ((byte1 & 0x0F) << 0x12) | (byte2 << 0x0C) |\n\t\t\t\t(byte3 << 0x06) | byte4;\n\t\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\t\treturn codePoint;\n\t\t\t}\n\t\t}\n\n\t\tthrow Error('Invalid UTF-8 detected');\n\t}\n\n\tvar byteArray;\n\tvar byteCount;\n\tvar byteIndex;\n\tfunction utf8decode(byteString) {\n\t\tbyteArray = ucs2decode(byteString);\n\t\tbyteCount = byteArray.length;\n\t\tbyteIndex = 0;\n\t\tvar codePoints = [];\n\t\tvar tmp;\n\t\twhile ((tmp = decodeSymbol()) !== false) {\n\t\t\tcodePoints.push(tmp);\n\t\t}\n\t\treturn ucs2encode(codePoints);\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\tvar utf8 = {\n\t\t'version': '2.0.0',\n\t\t'encode': utf8encode,\n\t\t'decode': utf8decode\n\t};\n\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine(function() {\n\t\t\treturn utf8;\n\t\t});\n\t}\telse if (freeExports && !freeExports.nodeType) {\n\t\tif (freeModule) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = utf8;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tvar object = {};\n\t\t\tvar hasOwnProperty = object.hasOwnProperty;\n\t\t\tfor (var key in utf8) {\n\t\t\t\thasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.utf8 = utf8;\n\t}\n\n}(this));\n","var Vue // late bind\nvar map = Object.create(null)\nvar shimmed = false\nvar isBrowserify = false\n\n/**\n * Determine compatibility and apply patch.\n *\n * @param {Function} vue\n * @param {Boolean} browserify\n */\n\nexports.install = function (vue, browserify) {\n  if (shimmed) return\n  shimmed = true\n\n  Vue = vue\n  isBrowserify = browserify\n\n  exports.compatible = !!Vue.internalDirectives\n  if (!exports.compatible) {\n    console.warn(\n      '[HMR] vue-loader hot reload is only compatible with ' +\n      'Vue.js 1.0.0+.'\n    )\n    return\n  }\n\n  // patch view directive\n  patchView(Vue.internalDirectives.component)\n  console.log('[HMR] Vue component hot reload shim applied.')\n  // shim router-view if present\n  var routerView = Vue.elementDirective('router-view')\n  if (routerView) {\n    patchView(routerView)\n    console.log('[HMR] vue-router <router-view> hot reload shim applied.')\n  }\n}\n\n/**\n * Shim the view directive (component or router-view).\n *\n * @param {Object} View\n */\n\nfunction patchView (View) {\n  var unbuild = View.unbuild\n  View.unbuild = function (defer) {\n    if (!this.hotUpdating) {\n      var prevComponent = this.childVM && this.childVM.constructor\n      removeView(prevComponent, this)\n      // defer = true means we are transitioning to a new\n      // Component. Register this new component to the list.\n      if (defer) {\n        addView(this.Component, this)\n      }\n    }\n    // call original\n    return unbuild.call(this, defer)\n  }\n}\n\n/**\n * Add a component view to a Component's hot list\n *\n * @param {Function} Component\n * @param {Directive} view - view directive instance\n */\n\nfunction addView (Component, view) {\n  var id = Component && Component.options.hotID\n  if (id) {\n    if (!map[id]) {\n      map[id] = {\n        Component: Component,\n        views: [],\n        instances: []\n      }\n    }\n    map[id].views.push(view)\n  }\n}\n\n/**\n * Remove a component view from a Component's hot list\n *\n * @param {Function} Component\n * @param {Directive} view - view directive instance\n */\n\nfunction removeView (Component, view) {\n  var id = Component && Component.options.hotID\n  if (id) {\n    map[id].views.$remove(view)\n  }\n}\n\n/**\n * Create a record for a hot module, which keeps track of its construcotr,\n * instnaces and views (component directives or router-views).\n *\n * @param {String} id\n * @param {Object} options\n */\n\nexports.createRecord = function (id, options) {\n  if (typeof options === 'function') {\n    options = options.options\n  }\n  if (typeof options.el !== 'string' && typeof options.data !== 'object') {\n    makeOptionsHot(id, options)\n    map[id] = {\n      Component: null,\n      views: [],\n      instances: []\n    }\n  }\n}\n\n/**\n * Make a Component options object hot.\n *\n * @param {String} id\n * @param {Object} options\n */\n\nfunction makeOptionsHot (id, options) {\n  options.hotID = id\n  injectHook(options, 'created', function () {\n    var record = map[id]\n    if (!record.Component) {\n      record.Component = this.constructor\n    }\n    record.instances.push(this)\n  })\n  injectHook(options, 'beforeDestroy', function () {\n    map[id].instances.$remove(this)\n  })\n}\n\n/**\n * Inject a hook to a hot reloadable component so that\n * we can keep track of it.\n *\n * @param {Object} options\n * @param {String} name\n * @param {Function} hook\n */\n\nfunction injectHook (options, name, hook) {\n  var existing = options[name]\n  options[name] = existing\n    ? Array.isArray(existing)\n      ? existing.concat(hook)\n      : [existing, hook]\n    : [hook]\n}\n\n/**\n * Update a hot component.\n *\n * @param {String} id\n * @param {Object|null} newOptions\n * @param {String|null} newTemplate\n */\n\nexports.update = function (id, newOptions, newTemplate) {\n  var record = map[id]\n  // force full-reload if an instance of the component is active but is not\n  // managed by a view\n  if (!record || (record.instances.length && !record.views.length)) {\n    console.log('[HMR] Root or manually-mounted instance modified. Full reload may be required.')\n    if (!isBrowserify) {\n      window.location.reload()\n    } else {\n      // browserify-hmr somehow sends incomplete bundle if we reload here\n      return\n    }\n  }\n  if (!isBrowserify) {\n    // browserify-hmr already logs this\n    console.log('[HMR] Updating component: ' + format(id))\n  }\n  var Component = record.Component\n  // update constructor\n  if (newOptions) {\n    // in case the user exports a constructor\n    Component = record.Component = typeof newOptions === 'function'\n      ? newOptions\n      : Vue.extend(newOptions)\n    makeOptionsHot(id, Component.options)\n  }\n  if (newTemplate) {\n    Component.options.template = newTemplate\n  }\n  // handle recursive lookup\n  if (Component.options.name) {\n    Component.options.components[Component.options.name] = Component\n  }\n  // reset constructor cached linker\n  Component.linker = null\n  // reload all views\n  record.views.forEach(function (view) {\n    updateView(view, Component)\n  })\n  // flush devtools\n  if (window.__VUE_DEVTOOLS_GLOBAL_HOOK__) {\n    window.__VUE_DEVTOOLS_GLOBAL_HOOK__.emit('flush')\n  }\n}\n\n/**\n * Update a component view instance\n *\n * @param {Directive} view\n * @param {Function} Component\n */\n\nfunction updateView (view, Component) {\n  if (!view._bound) {\n    return\n  }\n  view.Component = Component\n  view.hotUpdating = true\n  // disable transitions\n  view.vm._isCompiled = false\n  // save state\n  var state = extractState(view.childVM)\n  // remount, make sure to disable keep-alive\n  var keepAlive = view.keepAlive\n  view.keepAlive = false\n  view.mountComponent()\n  view.keepAlive = keepAlive\n  // restore state\n  restoreState(view.childVM, state, true)\n  // re-eanble transitions\n  view.vm._isCompiled = true\n  view.hotUpdating = false\n}\n\n/**\n * Extract state from a Vue instance.\n *\n * @param {Vue} vm\n * @return {Object}\n */\n\nfunction extractState (vm) {\n  return {\n    cid: vm.constructor.cid,\n    data: vm.$data,\n    children: vm.$children.map(extractState)\n  }\n}\n\n/**\n * Restore state to a reloaded Vue instance.\n *\n * @param {Vue} vm\n * @param {Object} state\n */\n\nfunction restoreState (vm, state, isRoot) {\n  var oldAsyncConfig\n  if (isRoot) {\n    // set Vue into sync mode during state rehydration\n    oldAsyncConfig = Vue.config.async\n    Vue.config.async = false\n  }\n  // actual restore\n  if (isRoot || !vm._props) {\n    vm.$data = state.data\n  } else {\n    Object.keys(state.data).forEach(function (key) {\n      if (!vm._props[key]) {\n        // for non-root, only restore non-props fields\n        vm.$data[key] = state.data[key]\n      }\n    })\n  }\n  // verify child consistency\n  var hasSameChildren = vm.$children.every(function (c, i) {\n    return state.children[i] && state.children[i].cid === c.constructor.cid\n  })\n  if (hasSameChildren) {\n    // rehydrate children\n    vm.$children.forEach(function (c, i) {\n      restoreState(c, state.children[i])\n    })\n  }\n  if (isRoot) {\n    Vue.config.async = oldAsyncConfig\n  }\n}\n\nfunction format (id) {\n  return id.match(/[^\\/]+\\.vue$/)[0]\n}\n","/*!\n * Vue.js v1.0.17\n * (c) 2016 Evan You\n * Released under the MIT License.\n */\n'use strict';\n\nfunction set(obj, key, val) {\n  if (hasOwn(obj, key)) {\n    obj[key] = val;\n    return;\n  }\n  if (obj._isVue) {\n    set(obj._data, key, val);\n    return;\n  }\n  var ob = obj.__ob__;\n  if (!ob) {\n    obj[key] = val;\n    return;\n  }\n  ob.convert(key, val);\n  ob.dep.notify();\n  if (ob.vms) {\n    var i = ob.vms.length;\n    while (i--) {\n      var vm = ob.vms[i];\n      vm._proxy(key);\n      vm._digest();\n    }\n  }\n  return val;\n}\n\n/**\n * Delete a property and trigger change if necessary.\n *\n * @param {Object} obj\n * @param {String} key\n */\n\nfunction del(obj, key) {\n  if (!hasOwn(obj, key)) {\n    return;\n  }\n  delete obj[key];\n  var ob = obj.__ob__;\n  if (!ob) {\n    return;\n  }\n  ob.dep.notify();\n  if (ob.vms) {\n    var i = ob.vms.length;\n    while (i--) {\n      var vm = ob.vms[i];\n      vm._unproxy(key);\n      vm._digest();\n    }\n  }\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n/**\n * Check whether the object has the property.\n *\n * @param {Object} obj\n * @param {String} key\n * @return {Boolean}\n */\n\nfunction hasOwn(obj, key) {\n  return hasOwnProperty.call(obj, key);\n}\n\n/**\n * Check if an expression is a literal value.\n *\n * @param {String} exp\n * @return {Boolean}\n */\n\nvar literalValueRE = /^\\s?(true|false|-?[\\d\\.]+|'[^']*'|\"[^\"]*\")\\s?$/;\n\nfunction isLiteral(exp) {\n  return literalValueRE.test(exp);\n}\n\n/**\n * Check if a string starts with $ or _\n *\n * @param {String} str\n * @return {Boolean}\n */\n\nfunction isReserved(str) {\n  var c = (str + '').charCodeAt(0);\n  return c === 0x24 || c === 0x5F;\n}\n\n/**\n * Guard text output, make sure undefined outputs\n * empty string\n *\n * @param {*} value\n * @return {String}\n */\n\nfunction _toString(value) {\n  return value == null ? '' : value.toString();\n}\n\n/**\n * Check and convert possible numeric strings to numbers\n * before setting back to data\n *\n * @param {*} value\n * @return {*|Number}\n */\n\nfunction toNumber(value) {\n  if (typeof value !== 'string') {\n    return value;\n  } else {\n    var parsed = Number(value);\n    return isNaN(parsed) ? value : parsed;\n  }\n}\n\n/**\n * Convert string boolean literals into real booleans.\n *\n * @param {*} value\n * @return {*|Boolean}\n */\n\nfunction toBoolean(value) {\n  return value === 'true' ? true : value === 'false' ? false : value;\n}\n\n/**\n * Strip quotes from a string\n *\n * @param {String} str\n * @return {String | false}\n */\n\nfunction stripQuotes(str) {\n  var a = str.charCodeAt(0);\n  var b = str.charCodeAt(str.length - 1);\n  return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;\n}\n\n/**\n * Camelize a hyphen-delmited string.\n *\n * @param {String} str\n * @return {String}\n */\n\nvar camelizeRE = /-(\\w)/g;\n\nfunction camelize(str) {\n  return str.replace(camelizeRE, toUpper);\n}\n\nfunction toUpper(_, c) {\n  return c ? c.toUpperCase() : '';\n}\n\n/**\n * Hyphenate a camelCase string.\n *\n * @param {String} str\n * @return {String}\n */\n\nvar hyphenateRE = /([a-z\\d])([A-Z])/g;\n\nfunction hyphenate(str) {\n  return str.replace(hyphenateRE, '$1-$2').toLowerCase();\n}\n\n/**\n * Converts hyphen/underscore/slash delimitered names into\n * camelized classNames.\n *\n * e.g. my-component => MyComponent\n *      some_else    => SomeElse\n *      some/comp    => SomeComp\n *\n * @param {String} str\n * @return {String}\n */\n\nvar classifyRE = /(?:^|[-_\\/])(\\w)/g;\n\nfunction classify(str) {\n  return str.replace(classifyRE, toUpper);\n}\n\n/**\n * Simple bind, faster than native\n *\n * @param {Function} fn\n * @param {Object} ctx\n * @return {Function}\n */\n\nfunction bind(fn, ctx) {\n  return function (a) {\n    var l = arguments.length;\n    return l ? l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a) : fn.call(ctx);\n  };\n}\n\n/**\n * Convert an Array-like object to a real Array.\n *\n * @param {Array-like} list\n * @param {Number} [start] - start index\n * @return {Array}\n */\n\nfunction toArray(list, start) {\n  start = start || 0;\n  var i = list.length - start;\n  var ret = new Array(i);\n  while (i--) {\n    ret[i] = list[i + start];\n  }\n  return ret;\n}\n\n/**\n * Mix properties into target object.\n *\n * @param {Object} to\n * @param {Object} from\n */\n\nfunction extend(to, from) {\n  var keys = Object.keys(from);\n  var i = keys.length;\n  while (i--) {\n    to[keys[i]] = from[keys[i]];\n  }\n  return to;\n}\n\n/**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n *\n * @param {*} obj\n * @return {Boolean}\n */\n\nfunction isObject(obj) {\n  return obj !== null && typeof obj === 'object';\n}\n\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n *\n * @param {*} obj\n * @return {Boolean}\n */\n\nvar toString = Object.prototype.toString;\nvar OBJECT_STRING = '[object Object]';\n\nfunction isPlainObject(obj) {\n  return toString.call(obj) === OBJECT_STRING;\n}\n\n/**\n * Array type check.\n *\n * @param {*} obj\n * @return {Boolean}\n */\n\nvar isArray = Array.isArray;\n\n/**\n * Define a non-enumerable property\n *\n * @param {Object} obj\n * @param {String} key\n * @param {*} val\n * @param {Boolean} [enumerable]\n */\n\nfunction def(obj, key, val, enumerable) {\n  Object.defineProperty(obj, key, {\n    value: val,\n    enumerable: !!enumerable,\n    writable: true,\n    configurable: true\n  });\n}\n\n/**\n * Debounce a function so it only gets called after the\n * input stops arriving after the given wait period.\n *\n * @param {Function} func\n * @param {Number} wait\n * @return {Function} - the debounced function\n */\n\nfunction _debounce(func, wait) {\n  var timeout, args, context, timestamp, result;\n  var later = function later() {\n    var last = Date.now() - timestamp;\n    if (last < wait && last >= 0) {\n      timeout = setTimeout(later, wait - last);\n    } else {\n      timeout = null;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    }\n  };\n  return function () {\n    context = this;\n    args = arguments;\n    timestamp = Date.now();\n    if (!timeout) {\n      timeout = setTimeout(later, wait);\n    }\n    return result;\n  };\n}\n\n/**\n * Manual indexOf because it's slightly faster than\n * native.\n *\n * @param {Array} arr\n * @param {*} obj\n */\n\nfunction indexOf(arr, obj) {\n  var i = arr.length;\n  while (i--) {\n    if (arr[i] === obj) return i;\n  }\n  return -1;\n}\n\n/**\n * Make a cancellable version of an async callback.\n *\n * @param {Function} fn\n * @return {Function}\n */\n\nfunction cancellable(fn) {\n  var cb = function cb() {\n    if (!cb.cancelled) {\n      return fn.apply(this, arguments);\n    }\n  };\n  cb.cancel = function () {\n    cb.cancelled = true;\n  };\n  return cb;\n}\n\n/**\n * Check if two values are loosely equal - that is,\n * if they are plain objects, do they have the same shape?\n *\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n */\n\nfunction looseEqual(a, b) {\n  /* eslint-disable eqeqeq */\n  return a == b || (isObject(a) && isObject(b) ? JSON.stringify(a) === JSON.stringify(b) : false);\n  /* eslint-enable eqeqeq */\n}\n\nvar hasProto = ('__proto__' in {});\n\n// Browser environment sniffing\nvar inBrowser = typeof window !== 'undefined' && Object.prototype.toString.call(window) !== '[object Object]';\n\n// detect devtools\nvar devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n// UA sniffing for working around browser-specific quirks\nvar UA = inBrowser && window.navigator.userAgent.toLowerCase();\nvar isIE9 = UA && UA.indexOf('msie 9.0') > 0;\nvar isAndroid = UA && UA.indexOf('android') > 0;\n\nvar transitionProp = undefined;\nvar transitionEndEvent = undefined;\nvar animationProp = undefined;\nvar animationEndEvent = undefined;\n\n// Transition property/event sniffing\nif (inBrowser && !isIE9) {\n  var isWebkitTrans = window.ontransitionend === undefined && window.onwebkittransitionend !== undefined;\n  var isWebkitAnim = window.onanimationend === undefined && window.onwebkitanimationend !== undefined;\n  transitionProp = isWebkitTrans ? 'WebkitTransition' : 'transition';\n  transitionEndEvent = isWebkitTrans ? 'webkitTransitionEnd' : 'transitionend';\n  animationProp = isWebkitAnim ? 'WebkitAnimation' : 'animation';\n  animationEndEvent = isWebkitAnim ? 'webkitAnimationEnd' : 'animationend';\n}\n\n/**\n * Defer a task to execute it asynchronously. Ideally this\n * should be executed as a microtask, so we leverage\n * MutationObserver if it's available, and fallback to\n * setTimeout(0).\n *\n * @param {Function} cb\n * @param {Object} ctx\n */\n\nvar nextTick = (function () {\n  var callbacks = [];\n  var pending = false;\n  var timerFunc;\n  function nextTickHandler() {\n    pending = false;\n    var copies = callbacks.slice(0);\n    callbacks = [];\n    for (var i = 0; i < copies.length; i++) {\n      copies[i]();\n    }\n  }\n\n  /* istanbul ignore if */\n  if (typeof MutationObserver !== 'undefined') {\n    var counter = 1;\n    var observer = new MutationObserver(nextTickHandler);\n    var textNode = document.createTextNode(counter);\n    observer.observe(textNode, {\n      characterData: true\n    });\n    timerFunc = function () {\n      counter = (counter + 1) % 2;\n      textNode.data = counter;\n    };\n  } else {\n    // webpack attempts to inject a shim for setImmediate\n    // if it is used as a global, so we have to work around that to\n    // avoid bundling unnecessary code.\n    var context = inBrowser ? window : typeof global !== 'undefined' ? global : {};\n    timerFunc = context.setImmediate || setTimeout;\n  }\n  return function (cb, ctx) {\n    var func = ctx ? function () {\n      cb.call(ctx);\n    } : cb;\n    callbacks.push(func);\n    if (pending) return;\n    pending = true;\n    timerFunc(nextTickHandler, 0);\n  };\n})();\n\nfunction Cache(limit) {\n  this.size = 0;\n  this.limit = limit;\n  this.head = this.tail = undefined;\n  this._keymap = Object.create(null);\n}\n\nvar p = Cache.prototype;\n\n/**\n * Put <value> into the cache associated with <key>.\n * Returns the entry which was removed to make room for\n * the new entry. Otherwise undefined is returned.\n * (i.e. if there was enough room already).\n *\n * @param {String} key\n * @param {*} value\n * @return {Entry|undefined}\n */\n\np.put = function (key, value) {\n  var removed;\n  if (this.size === this.limit) {\n    removed = this.shift();\n  }\n\n  var entry = this.get(key, true);\n  if (!entry) {\n    entry = {\n      key: key\n    };\n    this._keymap[key] = entry;\n    if (this.tail) {\n      this.tail.newer = entry;\n      entry.older = this.tail;\n    } else {\n      this.head = entry;\n    }\n    this.tail = entry;\n    this.size++;\n  }\n  entry.value = value;\n\n  return removed;\n};\n\n/**\n * Purge the least recently used (oldest) entry from the\n * cache. Returns the removed entry or undefined if the\n * cache was empty.\n */\n\np.shift = function () {\n  var entry = this.head;\n  if (entry) {\n    this.head = this.head.newer;\n    this.head.older = undefined;\n    entry.newer = entry.older = undefined;\n    this._keymap[entry.key] = undefined;\n    this.size--;\n  }\n  return entry;\n};\n\n/**\n * Get and register recent use of <key>. Returns the value\n * associated with <key> or undefined if not in cache.\n *\n * @param {String} key\n * @param {Boolean} returnEntry\n * @return {Entry|*}\n */\n\np.get = function (key, returnEntry) {\n  var entry = this._keymap[key];\n  if (entry === undefined) return;\n  if (entry === this.tail) {\n    return returnEntry ? entry : entry.value;\n  }\n  // HEAD--------------TAIL\n  //   <.older   .newer>\n  //  <--- add direction --\n  //   A  B  C  <D>  E\n  if (entry.newer) {\n    if (entry === this.head) {\n      this.head = entry.newer;\n    }\n    entry.newer.older = entry.older; // C <-- E.\n  }\n  if (entry.older) {\n    entry.older.newer = entry.newer; // C. --> E\n  }\n  entry.newer = undefined; // D --x\n  entry.older = this.tail; // D. --> E\n  if (this.tail) {\n    this.tail.newer = entry; // E. <-- D\n  }\n  this.tail = entry;\n  return returnEntry ? entry : entry.value;\n};\n\nvar cache$1 = new Cache(1000);\nvar filterTokenRE = /[^\\s'\"]+|'[^']*'|\"[^\"]*\"/g;\nvar reservedArgRE = /^in$|^-?\\d+/;\n\n/**\n * Parser state\n */\n\nvar str;\nvar dir;\nvar c;\nvar prev;\nvar i;\nvar l;\nvar lastFilterIndex;\nvar inSingle;\nvar inDouble;\nvar curly;\nvar square;\nvar paren;\n/**\n * Push a filter to the current directive object\n */\n\nfunction pushFilter() {\n  var exp = str.slice(lastFilterIndex, i).trim();\n  var filter;\n  if (exp) {\n    filter = {};\n    var tokens = exp.match(filterTokenRE);\n    filter.name = tokens[0];\n    if (tokens.length > 1) {\n      filter.args = tokens.slice(1).map(processFilterArg);\n    }\n  }\n  if (filter) {\n    (dir.filters = dir.filters || []).push(filter);\n  }\n  lastFilterIndex = i + 1;\n}\n\n/**\n * Check if an argument is dynamic and strip quotes.\n *\n * @param {String} arg\n * @return {Object}\n */\n\nfunction processFilterArg(arg) {\n  if (reservedArgRE.test(arg)) {\n    return {\n      value: toNumber(arg),\n      dynamic: false\n    };\n  } else {\n    var stripped = stripQuotes(arg);\n    var dynamic = stripped === arg;\n    return {\n      value: dynamic ? arg : stripped,\n      dynamic: dynamic\n    };\n  }\n}\n\n/**\n * Parse a directive value and extract the expression\n * and its filters into a descriptor.\n *\n * Example:\n *\n * \"a + 1 | uppercase\" will yield:\n * {\n *   expression: 'a + 1',\n *   filters: [\n *     { name: 'uppercase', args: null }\n *   ]\n * }\n *\n * @param {String} str\n * @return {Object}\n */\n\nfunction parseDirective(s) {\n  var hit = cache$1.get(s);\n  if (hit) {\n    return hit;\n  }\n\n  // reset parser state\n  str = s;\n  inSingle = inDouble = false;\n  curly = square = paren = 0;\n  lastFilterIndex = 0;\n  dir = {};\n\n  for (i = 0, l = str.length; i < l; i++) {\n    prev = c;\n    c = str.charCodeAt(i);\n    if (inSingle) {\n      // check single quote\n      if (c === 0x27 && prev !== 0x5C) inSingle = !inSingle;\n    } else if (inDouble) {\n      // check double quote\n      if (c === 0x22 && prev !== 0x5C) inDouble = !inDouble;\n    } else if (c === 0x7C && // pipe\n    str.charCodeAt(i + 1) !== 0x7C && str.charCodeAt(i - 1) !== 0x7C) {\n      if (dir.expression == null) {\n        // first filter, end of expression\n        lastFilterIndex = i + 1;\n        dir.expression = str.slice(0, i).trim();\n      } else {\n        // already has filter\n        pushFilter();\n      }\n    } else {\n      switch (c) {\n        case 0x22:\n          inDouble = true;break; // \"\n        case 0x27:\n          inSingle = true;break; // '\n        case 0x28:\n          paren++;break; // (\n        case 0x29:\n          paren--;break; // )\n        case 0x5B:\n          square++;break; // [\n        case 0x5D:\n          square--;break; // ]\n        case 0x7B:\n          curly++;break; // {\n        case 0x7D:\n          curly--;break; // }\n      }\n    }\n  }\n\n  if (dir.expression == null) {\n    dir.expression = str.slice(0, i).trim();\n  } else if (lastFilterIndex !== 0) {\n    pushFilter();\n  }\n\n  cache$1.put(s, dir);\n  return dir;\n}\n\nvar directive = Object.freeze({\n  parseDirective: parseDirective\n});\n\nvar regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\nvar cache = undefined;\nvar tagRE = undefined;\nvar htmlRE = undefined;\n/**\n * Escape a string so it can be used in a RegExp\n * constructor.\n *\n * @param {String} str\n */\n\nfunction escapeRegex(str) {\n  return str.replace(regexEscapeRE, '\\\\$&');\n}\n\nfunction compileRegex() {\n  var open = escapeRegex(config.delimiters[0]);\n  var close = escapeRegex(config.delimiters[1]);\n  var unsafeOpen = escapeRegex(config.unsafeDelimiters[0]);\n  var unsafeClose = escapeRegex(config.unsafeDelimiters[1]);\n  tagRE = new RegExp(unsafeOpen + '(.+?)' + unsafeClose + '|' + open + '(.+?)' + close, 'g');\n  htmlRE = new RegExp('^' + unsafeOpen + '.*' + unsafeClose + '$');\n  // reset cache\n  cache = new Cache(1000);\n}\n\n/**\n * Parse a template text string into an array of tokens.\n *\n * @param {String} text\n * @return {Array<Object> | null}\n *               - {String} type\n *               - {String} value\n *               - {Boolean} [html]\n *               - {Boolean} [oneTime]\n */\n\nfunction parseText(text) {\n  if (!cache) {\n    compileRegex();\n  }\n  var hit = cache.get(text);\n  if (hit) {\n    return hit;\n  }\n  text = text.replace(/\\n/g, '');\n  if (!tagRE.test(text)) {\n    return null;\n  }\n  var tokens = [];\n  var lastIndex = tagRE.lastIndex = 0;\n  var match, index, html, value, first, oneTime;\n  /* eslint-disable no-cond-assign */\n  while (match = tagRE.exec(text)) {\n    /* eslint-enable no-cond-assign */\n    index = match.index;\n    // push text token\n    if (index > lastIndex) {\n      tokens.push({\n        value: text.slice(lastIndex, index)\n      });\n    }\n    // tag token\n    html = htmlRE.test(match[0]);\n    value = html ? match[1] : match[2];\n    first = value.charCodeAt(0);\n    oneTime = first === 42; // *\n    value = oneTime ? value.slice(1) : value;\n    tokens.push({\n      tag: true,\n      value: value.trim(),\n      html: html,\n      oneTime: oneTime\n    });\n    lastIndex = index + match[0].length;\n  }\n  if (lastIndex < text.length) {\n    tokens.push({\n      value: text.slice(lastIndex)\n    });\n  }\n  cache.put(text, tokens);\n  return tokens;\n}\n\n/**\n * Format a list of tokens into an expression.\n * e.g. tokens parsed from 'a {{b}} c' can be serialized\n * into one single expression as '\"a \" + b + \" c\"'.\n *\n * @param {Array} tokens\n * @param {Vue} [vm]\n * @return {String}\n */\n\nfunction tokensToExp(tokens, vm) {\n  if (tokens.length > 1) {\n    return tokens.map(function (token) {\n      return formatToken(token, vm);\n    }).join('+');\n  } else {\n    return formatToken(tokens[0], vm, true);\n  }\n}\n\n/**\n * Format a single token.\n *\n * @param {Object} token\n * @param {Vue} [vm]\n * @param {Boolean} [single]\n * @return {String}\n */\n\nfunction formatToken(token, vm, single) {\n  return token.tag ? token.oneTime && vm ? '\"' + vm.$eval(token.value) + '\"' : inlineFilters(token.value, single) : '\"' + token.value + '\"';\n}\n\n/**\n * For an attribute with multiple interpolation tags,\n * e.g. attr=\"some-{{thing | filter}}\", in order to combine\n * the whole thing into a single watchable expression, we\n * have to inline those filters. This function does exactly\n * that. This is a bit hacky but it avoids heavy changes\n * to directive parser and watcher mechanism.\n *\n * @param {String} exp\n * @param {Boolean} single\n * @return {String}\n */\n\nvar filterRE = /[^|]\\|[^|]/;\nfunction inlineFilters(exp, single) {\n  if (!filterRE.test(exp)) {\n    return single ? exp : '(' + exp + ')';\n  } else {\n    var dir = parseDirective(exp);\n    if (!dir.filters) {\n      return '(' + exp + ')';\n    } else {\n      return 'this._applyFilters(' + dir.expression + // value\n      ',null,' + // oldValue (null for read)\n      JSON.stringify(dir.filters) + // filter descriptors\n      ',false)'; // write?\n    }\n  }\n}\n\nvar text = Object.freeze({\n  compileRegex: compileRegex,\n  parseText: parseText,\n  tokensToExp: tokensToExp\n});\n\nvar delimiters = ['{{', '}}'];\nvar unsafeDelimiters = ['{{{', '}}}'];\n\nvar config = Object.defineProperties({\n\n  /**\n   * Whether to print debug messages.\n   * Also enables stack trace for warnings.\n   *\n   * @type {Boolean}\n   */\n\n  debug: false,\n\n  /**\n   * Whether to suppress warnings.\n   *\n   * @type {Boolean}\n   */\n\n  silent: false,\n\n  /**\n   * Whether to use async rendering.\n   */\n\n  async: true,\n\n  /**\n   * Whether to warn against errors caught when evaluating\n   * expressions.\n   */\n\n  warnExpressionErrors: true,\n\n  /**\n   * Internal flag to indicate the delimiters have been\n   * changed.\n   *\n   * @type {Boolean}\n   */\n\n  _delimitersChanged: true,\n\n  /**\n   * List of asset types that a component can own.\n   *\n   * @type {Array}\n   */\n\n  _assetTypes: ['component', 'directive', 'elementDirective', 'filter', 'transition', 'partial'],\n\n  /**\n   * prop binding modes\n   */\n\n  _propBindingModes: {\n    ONE_WAY: 0,\n    TWO_WAY: 1,\n    ONE_TIME: 2\n  },\n\n  /**\n   * Max circular updates allowed in a batcher flush cycle.\n   */\n\n  _maxUpdateCount: 100\n\n}, {\n  delimiters: { /**\n                 * Interpolation delimiters. Changing these would trigger\n                 * the text parser to re-compile the regular expressions.\n                 *\n                 * @type {Array<String>}\n                 */\n\n    get: function get() {\n      return delimiters;\n    },\n    set: function set(val) {\n      delimiters = val;\n      compileRegex();\n    },\n    configurable: true,\n    enumerable: true\n  },\n  unsafeDelimiters: {\n    get: function get() {\n      return unsafeDelimiters;\n    },\n    set: function set(val) {\n      unsafeDelimiters = val;\n      compileRegex();\n    },\n    configurable: true,\n    enumerable: true\n  }\n});\n\nvar warn = undefined;\n\nif (process.env.NODE_ENV !== 'production') {\n  (function () {\n    var hasConsole = typeof console !== 'undefined';\n    warn = function (msg, e) {\n      if (hasConsole && (!config.silent || config.debug)) {\n        console.warn('[Vue warn]: ' + msg);\n        /* istanbul ignore if */\n        if (config.debug) {\n          if (e) {\n            throw e;\n          } else {\n            console.warn(new Error('Warning Stack Trace').stack);\n          }\n        }\n      }\n    };\n  })();\n}\n\n/**\n * Append with transition.\n *\n * @param {Element} el\n * @param {Element} target\n * @param {Vue} vm\n * @param {Function} [cb]\n */\n\nfunction appendWithTransition(el, target, vm, cb) {\n  applyTransition(el, 1, function () {\n    target.appendChild(el);\n  }, vm, cb);\n}\n\n/**\n * InsertBefore with transition.\n *\n * @param {Element} el\n * @param {Element} target\n * @param {Vue} vm\n * @param {Function} [cb]\n */\n\nfunction beforeWithTransition(el, target, vm, cb) {\n  applyTransition(el, 1, function () {\n    before(el, target);\n  }, vm, cb);\n}\n\n/**\n * Remove with transition.\n *\n * @param {Element} el\n * @param {Vue} vm\n * @param {Function} [cb]\n */\n\nfunction removeWithTransition(el, vm, cb) {\n  applyTransition(el, -1, function () {\n    remove(el);\n  }, vm, cb);\n}\n\n/**\n * Apply transitions with an operation callback.\n *\n * @param {Element} el\n * @param {Number} direction\n *                  1: enter\n *                 -1: leave\n * @param {Function} op - the actual DOM operation\n * @param {Vue} vm\n * @param {Function} [cb]\n */\n\nfunction applyTransition(el, direction, op, vm, cb) {\n  var transition = el.__v_trans;\n  if (!transition ||\n  // skip if there are no js hooks and CSS transition is\n  // not supported\n  !transition.hooks && !transitionEndEvent ||\n  // skip transitions for initial compile\n  !vm._isCompiled ||\n  // if the vm is being manipulated by a parent directive\n  // during the parent's compilation phase, skip the\n  // animation.\n  vm.$parent && !vm.$parent._isCompiled) {\n    op();\n    if (cb) cb();\n    return;\n  }\n  var action = direction > 0 ? 'enter' : 'leave';\n  transition[action](op, cb);\n}\n\nvar transition = Object.freeze({\n  appendWithTransition: appendWithTransition,\n  beforeWithTransition: beforeWithTransition,\n  removeWithTransition: removeWithTransition,\n  applyTransition: applyTransition\n});\n\n/**\n * Query an element selector if it's not an element already.\n *\n * @param {String|Element} el\n * @return {Element}\n */\n\nfunction query(el) {\n  if (typeof el === 'string') {\n    var selector = el;\n    el = document.querySelector(el);\n    if (!el) {\n      process.env.NODE_ENV !== 'production' && warn('Cannot find element: ' + selector);\n    }\n  }\n  return el;\n}\n\n/**\n * Check if a node is in the document.\n * Note: document.documentElement.contains should work here\n * but always returns false for comment nodes in phantomjs,\n * making unit tests difficult. This is fixed by doing the\n * contains() check on the node's parentNode instead of\n * the node itself.\n *\n * @param {Node} node\n * @return {Boolean}\n */\n\nfunction inDoc(node) {\n  var doc = document.documentElement;\n  var parent = node && node.parentNode;\n  return doc === node || doc === parent || !!(parent && parent.nodeType === 1 && doc.contains(parent));\n}\n\n/**\n * Get and remove an attribute from a node.\n *\n * @param {Node} node\n * @param {String} _attr\n */\n\nfunction getAttr(node, _attr) {\n  var val = node.getAttribute(_attr);\n  if (val !== null) {\n    node.removeAttribute(_attr);\n  }\n  return val;\n}\n\n/**\n * Get an attribute with colon or v-bind: prefix.\n *\n * @param {Node} node\n * @param {String} name\n * @return {String|null}\n */\n\nfunction getBindAttr(node, name) {\n  var val = getAttr(node, ':' + name);\n  if (val === null) {\n    val = getAttr(node, 'v-bind:' + name);\n  }\n  return val;\n}\n\n/**\n * Check the presence of a bind attribute.\n *\n * @param {Node} node\n * @param {String} name\n * @return {Boolean}\n */\n\nfunction hasBindAttr(node, name) {\n  return node.hasAttribute(name) || node.hasAttribute(':' + name) || node.hasAttribute('v-bind:' + name);\n}\n\n/**\n * Insert el before target\n *\n * @param {Element} el\n * @param {Element} target\n */\n\nfunction before(el, target) {\n  target.parentNode.insertBefore(el, target);\n}\n\n/**\n * Insert el after target\n *\n * @param {Element} el\n * @param {Element} target\n */\n\nfunction after(el, target) {\n  if (target.nextSibling) {\n    before(el, target.nextSibling);\n  } else {\n    target.parentNode.appendChild(el);\n  }\n}\n\n/**\n * Remove el from DOM\n *\n * @param {Element} el\n */\n\nfunction remove(el) {\n  el.parentNode.removeChild(el);\n}\n\n/**\n * Prepend el to target\n *\n * @param {Element} el\n * @param {Element} target\n */\n\nfunction prepend(el, target) {\n  if (target.firstChild) {\n    before(el, target.firstChild);\n  } else {\n    target.appendChild(el);\n  }\n}\n\n/**\n * Replace target with el\n *\n * @param {Element} target\n * @param {Element} el\n */\n\nfunction replace(target, el) {\n  var parent = target.parentNode;\n  if (parent) {\n    parent.replaceChild(el, target);\n  }\n}\n\n/**\n * Add event listener shorthand.\n *\n * @param {Element} el\n * @param {String} event\n * @param {Function} cb\n * @param {Boolean} [useCapture]\n */\n\nfunction on(el, event, cb, useCapture) {\n  el.addEventListener(event, cb, useCapture);\n}\n\n/**\n * Remove event listener shorthand.\n *\n * @param {Element} el\n * @param {String} event\n * @param {Function} cb\n */\n\nfunction off(el, event, cb) {\n  el.removeEventListener(event, cb);\n}\n\n/**\n * In IE9, setAttribute('class') will result in empty class\n * if the element also has the :class attribute; However in\n * PhantomJS, setting `className` does not work on SVG elements...\n * So we have to do a conditional check here.\n *\n * @param {Element} el\n * @param {String} cls\n */\n\nfunction setClass(el, cls) {\n  /* istanbul ignore if */\n  if (isIE9 && !/svg$/.test(el.namespaceURI)) {\n    el.className = cls;\n  } else {\n    el.setAttribute('class', cls);\n  }\n}\n\n/**\n * Add class with compatibility for IE & SVG\n *\n * @param {Element} el\n * @param {String} cls\n */\n\nfunction addClass(el, cls) {\n  if (el.classList) {\n    el.classList.add(cls);\n  } else {\n    var cur = ' ' + (el.getAttribute('class') || '') + ' ';\n    if (cur.indexOf(' ' + cls + ' ') < 0) {\n      setClass(el, (cur + cls).trim());\n    }\n  }\n}\n\n/**\n * Remove class with compatibility for IE & SVG\n *\n * @param {Element} el\n * @param {String} cls\n */\n\nfunction removeClass(el, cls) {\n  if (el.classList) {\n    el.classList.remove(cls);\n  } else {\n    var cur = ' ' + (el.getAttribute('class') || '') + ' ';\n    var tar = ' ' + cls + ' ';\n    while (cur.indexOf(tar) >= 0) {\n      cur = cur.replace(tar, ' ');\n    }\n    setClass(el, cur.trim());\n  }\n  if (!el.className) {\n    el.removeAttribute('class');\n  }\n}\n\n/**\n * Extract raw content inside an element into a temporary\n * container div\n *\n * @param {Element} el\n * @param {Boolean} asFragment\n * @return {Element|DocumentFragment}\n */\n\nfunction extractContent(el, asFragment) {\n  var child;\n  var rawContent;\n  /* istanbul ignore if */\n  if (isTemplate(el) && isFragment(el.content)) {\n    el = el.content;\n  }\n  if (el.hasChildNodes()) {\n    trimNode(el);\n    rawContent = asFragment ? document.createDocumentFragment() : document.createElement('div');\n    /* eslint-disable no-cond-assign */\n    while (child = el.firstChild) {\n      /* eslint-enable no-cond-assign */\n      rawContent.appendChild(child);\n    }\n  }\n  return rawContent;\n}\n\n/**\n * Trim possible empty head/tail text and comment\n * nodes inside a parent.\n *\n * @param {Node} node\n */\n\nfunction trimNode(node) {\n  var child;\n  /* eslint-disable no-sequences */\n  while ((child = node.firstChild, isTrimmable(child))) {\n    node.removeChild(child);\n  }\n  while ((child = node.lastChild, isTrimmable(child))) {\n    node.removeChild(child);\n  }\n  /* eslint-enable no-sequences */\n}\n\nfunction isTrimmable(node) {\n  return node && (node.nodeType === 3 && !node.data.trim() || node.nodeType === 8);\n}\n\n/**\n * Check if an element is a template tag.\n * Note if the template appears inside an SVG its tagName\n * will be in lowercase.\n *\n * @param {Element} el\n */\n\nfunction isTemplate(el) {\n  return el.tagName && el.tagName.toLowerCase() === 'template';\n}\n\n/**\n * Create an \"anchor\" for performing dom insertion/removals.\n * This is used in a number of scenarios:\n * - fragment instance\n * - v-html\n * - v-if\n * - v-for\n * - component\n *\n * @param {String} content\n * @param {Boolean} persist - IE trashes empty textNodes on\n *                            cloneNode(true), so in certain\n *                            cases the anchor needs to be\n *                            non-empty to be persisted in\n *                            templates.\n * @return {Comment|Text}\n */\n\nfunction createAnchor(content, persist) {\n  var anchor = config.debug ? document.createComment(content) : document.createTextNode(persist ? ' ' : '');\n  anchor.__v_anchor = true;\n  return anchor;\n}\n\n/**\n * Find a component ref attribute that starts with $.\n *\n * @param {Element} node\n * @return {String|undefined}\n */\n\nvar refRE = /^v-ref:/;\n\nfunction findRef(node) {\n  if (node.hasAttributes()) {\n    var attrs = node.attributes;\n    for (var i = 0, l = attrs.length; i < l; i++) {\n      var name = attrs[i].name;\n      if (refRE.test(name)) {\n        return camelize(name.replace(refRE, ''));\n      }\n    }\n  }\n}\n\n/**\n * Map a function to a range of nodes .\n *\n * @param {Node} node\n * @param {Node} end\n * @param {Function} op\n */\n\nfunction mapNodeRange(node, end, op) {\n  var next;\n  while (node !== end) {\n    next = node.nextSibling;\n    op(node);\n    node = next;\n  }\n  op(end);\n}\n\n/**\n * Remove a range of nodes with transition, store\n * the nodes in a fragment with correct ordering,\n * and call callback when done.\n *\n * @param {Node} start\n * @param {Node} end\n * @param {Vue} vm\n * @param {DocumentFragment} frag\n * @param {Function} cb\n */\n\nfunction removeNodeRange(start, end, vm, frag, cb) {\n  var done = false;\n  var removed = 0;\n  var nodes = [];\n  mapNodeRange(start, end, function (node) {\n    if (node === end) done = true;\n    nodes.push(node);\n    removeWithTransition(node, vm, onRemoved);\n  });\n  function onRemoved() {\n    removed++;\n    if (done && removed >= nodes.length) {\n      for (var i = 0; i < nodes.length; i++) {\n        frag.appendChild(nodes[i]);\n      }\n      cb && cb();\n    }\n  }\n}\n\n/**\n * Check if a node is a DocumentFragment.\n *\n * @param {Node} node\n * @return {Boolean}\n */\n\nfunction isFragment(node) {\n  return node && node.nodeType === 11;\n}\n\n/**\n * Get outerHTML of elements, taking care\n * of SVG elements in IE as well.\n *\n * @param {Element} el\n * @return {String}\n */\n\nfunction getOuterHTML(el) {\n  if (el.outerHTML) {\n    return el.outerHTML;\n  } else {\n    var container = document.createElement('div');\n    container.appendChild(el.cloneNode(true));\n    return container.innerHTML;\n  }\n}\n\nvar commonTagRE = /^(div|p|span|img|a|b|i|br|ul|ol|li|h1|h2|h3|h4|h5|h6|code|pre|table|th|td|tr|form|label|input|select|option|nav|article|section|header|footer)$/;\nvar reservedTagRE = /^(slot|partial|component)$/;\n\nvar isUnknownElement = undefined;\nif (process.env.NODE_ENV !== 'production') {\n  isUnknownElement = function (el, tag) {\n    if (tag.indexOf('-') > -1) {\n      // http://stackoverflow.com/a/28210364/1070244\n      return el.constructor === window.HTMLUnknownElement || el.constructor === window.HTMLElement;\n    } else {\n      return (/HTMLUnknownElement/.test(el.toString()) &&\n        // Chrome returns unknown for several HTML5 elements.\n        // https://code.google.com/p/chromium/issues/detail?id=540526\n        !/^(data|time|rtc|rb)$/.test(tag)\n      );\n    }\n  };\n}\n\n/**\n * Check if an element is a component, if yes return its\n * component id.\n *\n * @param {Element} el\n * @param {Object} options\n * @return {Object|undefined}\n */\n\nfunction checkComponentAttr(el, options) {\n  var tag = el.tagName.toLowerCase();\n  var hasAttrs = el.hasAttributes();\n  if (!commonTagRE.test(tag) && !reservedTagRE.test(tag)) {\n    if (resolveAsset(options, 'components', tag)) {\n      return { id: tag };\n    } else {\n      var is = hasAttrs && getIsBinding(el);\n      if (is) {\n        return is;\n      } else if (process.env.NODE_ENV !== 'production') {\n        var expectedTag = options._componentNameMap && options._componentNameMap[tag];\n        if (expectedTag) {\n          warn('Unknown custom element: <' + tag + '> - ' + 'did you mean <' + expectedTag + '>? ' + 'HTML is case-insensitive, remember to use kebab-case in templates.');\n        } else if (isUnknownElement(el, tag)) {\n          warn('Unknown custom element: <' + tag + '> - did you ' + 'register the component correctly? For recursive components, ' + 'make sure to provide the \"name\" option.');\n        }\n      }\n    }\n  } else if (hasAttrs) {\n    return getIsBinding(el);\n  }\n}\n\n/**\n * Get \"is\" binding from an element.\n *\n * @param {Element} el\n * @return {Object|undefined}\n */\n\nfunction getIsBinding(el) {\n  // dynamic syntax\n  var exp = getAttr(el, 'is');\n  if (exp != null) {\n    return { id: exp };\n  } else {\n    exp = getBindAttr(el, 'is');\n    if (exp != null) {\n      return { id: exp, dynamic: true };\n    }\n  }\n}\n\n/**\n * Set a prop's initial value on a vm and its data object.\n *\n * @param {Vue} vm\n * @param {Object} prop\n * @param {*} value\n */\n\nfunction initProp(vm, prop, value) {\n  var key = prop.path;\n  value = coerceProp(prop, value);\n  vm[key] = vm._data[key] = assertProp(prop, value) ? value : undefined;\n}\n\n/**\n * Assert whether a prop is valid.\n *\n * @param {Object} prop\n * @param {*} value\n */\n\nfunction assertProp(prop, value) {\n  if (!prop.options.required && ( // non-required\n  prop.raw === null || // abscent\n  value == null) // null or undefined\n  ) {\n      return true;\n    }\n  var options = prop.options;\n  var type = options.type;\n  var valid = true;\n  var expectedType;\n  if (type) {\n    if (type === String) {\n      expectedType = 'string';\n      valid = typeof value === expectedType;\n    } else if (type === Number) {\n      expectedType = 'number';\n      valid = typeof value === 'number';\n    } else if (type === Boolean) {\n      expectedType = 'boolean';\n      valid = typeof value === 'boolean';\n    } else if (type === Function) {\n      expectedType = 'function';\n      valid = typeof value === 'function';\n    } else if (type === Object) {\n      expectedType = 'object';\n      valid = isPlainObject(value);\n    } else if (type === Array) {\n      expectedType = 'array';\n      valid = isArray(value);\n    } else {\n      valid = value instanceof type;\n    }\n  }\n  if (!valid) {\n    process.env.NODE_ENV !== 'production' && warn('Invalid prop: type check failed for ' + prop.path + '=\"' + prop.raw + '\".' + ' Expected ' + formatType(expectedType) + ', got ' + formatValue(value) + '.');\n    return false;\n  }\n  var validator = options.validator;\n  if (validator) {\n    if (!validator(value)) {\n      process.env.NODE_ENV !== 'production' && warn('Invalid prop: custom validator check failed for ' + prop.path + '=\"' + prop.raw + '\"');\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Force parsing value with coerce option.\n *\n * @param {*} value\n * @param {Object} options\n * @return {*}\n */\n\nfunction coerceProp(prop, value) {\n  var coerce = prop.options.coerce;\n  if (!coerce) {\n    return value;\n  }\n  // coerce is a function\n  return coerce(value);\n}\n\nfunction formatType(val) {\n  return val ? val.charAt(0).toUpperCase() + val.slice(1) : 'custom type';\n}\n\nfunction formatValue(val) {\n  return Object.prototype.toString.call(val).slice(8, -1);\n}\n\n/**\n * Option overwriting strategies are functions that handle\n * how to merge a parent option value and a child option\n * value into the final value.\n *\n * All strategy functions follow the same signature:\n *\n * @param {*} parentVal\n * @param {*} childVal\n * @param {Vue} [vm]\n */\n\nvar strats = config.optionMergeStrategies = Object.create(null);\n\n/**\n * Helper that recursively merges two data objects together.\n */\n\nfunction mergeData(to, from) {\n  var key, toVal, fromVal;\n  for (key in from) {\n    toVal = to[key];\n    fromVal = from[key];\n    if (!hasOwn(to, key)) {\n      set(to, key, fromVal);\n    } else if (isObject(toVal) && isObject(fromVal)) {\n      mergeData(toVal, fromVal);\n    }\n  }\n  return to;\n}\n\n/**\n * Data\n */\n\nstrats.data = function (parentVal, childVal, vm) {\n  if (!vm) {\n    // in a Vue.extend merge, both should be functions\n    if (!childVal) {\n      return parentVal;\n    }\n    if (typeof childVal !== 'function') {\n      process.env.NODE_ENV !== 'production' && warn('The \"data\" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.');\n      return parentVal;\n    }\n    if (!parentVal) {\n      return childVal;\n    }\n    // when parentVal & childVal are both present,\n    // we need to return a function that returns the\n    // merged result of both functions... no need to\n    // check if parentVal is a function here because\n    // it has to be a function to pass previous merges.\n    return function mergedDataFn() {\n      return mergeData(childVal.call(this), parentVal.call(this));\n    };\n  } else if (parentVal || childVal) {\n    return function mergedInstanceDataFn() {\n      // instance merge\n      var instanceData = typeof childVal === 'function' ? childVal.call(vm) : childVal;\n      var defaultData = typeof parentVal === 'function' ? parentVal.call(vm) : undefined;\n      if (instanceData) {\n        return mergeData(instanceData, defaultData);\n      } else {\n        return defaultData;\n      }\n    };\n  }\n};\n\n/**\n * El\n */\n\nstrats.el = function (parentVal, childVal, vm) {\n  if (!vm && childVal && typeof childVal !== 'function') {\n    process.env.NODE_ENV !== 'production' && warn('The \"el\" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.');\n    return;\n  }\n  var ret = childVal || parentVal;\n  // invoke the element factory if this is instance merge\n  return vm && typeof ret === 'function' ? ret.call(vm) : ret;\n};\n\n/**\n * Hooks and param attributes are merged as arrays.\n */\n\nstrats.init = strats.created = strats.ready = strats.attached = strats.detached = strats.beforeCompile = strats.compiled = strats.beforeDestroy = strats.destroyed = strats.activate = function (parentVal, childVal) {\n  return childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal;\n};\n\n/**\n * 0.11 deprecation warning\n */\n\nstrats.paramAttributes = function () {\n  /* istanbul ignore next */\n  process.env.NODE_ENV !== 'production' && warn('\"paramAttributes\" option has been deprecated in 0.12. ' + 'Use \"props\" instead.');\n};\n\n/**\n * Assets\n *\n * When a vm is present (instance creation), we need to do\n * a three-way merge between constructor options, instance\n * options and parent options.\n */\n\nfunction mergeAssets(parentVal, childVal) {\n  var res = Object.create(parentVal);\n  return childVal ? extend(res, guardArrayAssets(childVal)) : res;\n}\n\nconfig._assetTypes.forEach(function (type) {\n  strats[type + 's'] = mergeAssets;\n});\n\n/**\n * Events & Watchers.\n *\n * Events & watchers hashes should not overwrite one\n * another, so we merge them as arrays.\n */\n\nstrats.watch = strats.events = function (parentVal, childVal) {\n  if (!childVal) return parentVal;\n  if (!parentVal) return childVal;\n  var ret = {};\n  extend(ret, parentVal);\n  for (var key in childVal) {\n    var parent = ret[key];\n    var child = childVal[key];\n    if (parent && !isArray(parent)) {\n      parent = [parent];\n    }\n    ret[key] = parent ? parent.concat(child) : [child];\n  }\n  return ret;\n};\n\n/**\n * Other object hashes.\n */\n\nstrats.props = strats.methods = strats.computed = function (parentVal, childVal) {\n  if (!childVal) return parentVal;\n  if (!parentVal) return childVal;\n  var ret = Object.create(null);\n  extend(ret, parentVal);\n  extend(ret, childVal);\n  return ret;\n};\n\n/**\n * Default strategy.\n */\n\nvar defaultStrat = function defaultStrat(parentVal, childVal) {\n  return childVal === undefined ? parentVal : childVal;\n};\n\n/**\n * Make sure component options get converted to actual\n * constructors.\n *\n * @param {Object} options\n */\n\nfunction guardComponents(options) {\n  if (options.components) {\n    var components = options.components = guardArrayAssets(options.components);\n    var ids = Object.keys(components);\n    var def;\n    if (process.env.NODE_ENV !== 'production') {\n      var map = options._componentNameMap = {};\n    }\n    for (var i = 0, l = ids.length; i < l; i++) {\n      var key = ids[i];\n      if (commonTagRE.test(key) || reservedTagRE.test(key)) {\n        process.env.NODE_ENV !== 'production' && warn('Do not use built-in or reserved HTML elements as component ' + 'id: ' + key);\n        continue;\n      }\n      // record a all lowercase <-> kebab-case mapping for\n      // possible custom element case error warning\n      if (process.env.NODE_ENV !== 'production') {\n        map[key.replace(/-/g, '').toLowerCase()] = hyphenate(key);\n      }\n      def = components[key];\n      if (isPlainObject(def)) {\n        components[key] = Vue.extend(def);\n      }\n    }\n  }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * Object-based format.\n *\n * @param {Object} options\n */\n\nfunction guardProps(options) {\n  var props = options.props;\n  var i, val;\n  if (isArray(props)) {\n    options.props = {};\n    i = props.length;\n    while (i--) {\n      val = props[i];\n      if (typeof val === 'string') {\n        options.props[val] = null;\n      } else if (val.name) {\n        options.props[val.name] = val;\n      }\n    }\n  } else if (isPlainObject(props)) {\n    var keys = Object.keys(props);\n    i = keys.length;\n    while (i--) {\n      val = props[keys[i]];\n      if (typeof val === 'function') {\n        props[keys[i]] = { type: val };\n      }\n    }\n  }\n}\n\n/**\n * Guard an Array-format assets option and converted it\n * into the key-value Object format.\n *\n * @param {Object|Array} assets\n * @return {Object}\n */\n\nfunction guardArrayAssets(assets) {\n  if (isArray(assets)) {\n    var res = {};\n    var i = assets.length;\n    var asset;\n    while (i--) {\n      asset = assets[i];\n      var id = typeof asset === 'function' ? asset.options && asset.options.name || asset.id : asset.name || asset.id;\n      if (!id) {\n        process.env.NODE_ENV !== 'production' && warn('Array-syntax assets must provide a \"name\" or \"id\" field.');\n      } else {\n        res[id] = asset;\n      }\n    }\n    return res;\n  }\n  return assets;\n}\n\n/**\n * Merge two option objects into a new one.\n * Core utility used in both instantiation and inheritance.\n *\n * @param {Object} parent\n * @param {Object} child\n * @param {Vue} [vm] - if vm is present, indicates this is\n *                     an instantiation merge.\n */\n\nfunction mergeOptions(parent, child, vm) {\n  guardComponents(child);\n  guardProps(child);\n  var options = {};\n  var key;\n  if (child.mixins) {\n    for (var i = 0, l = child.mixins.length; i < l; i++) {\n      parent = mergeOptions(parent, child.mixins[i], vm);\n    }\n  }\n  for (key in parent) {\n    mergeField(key);\n  }\n  for (key in child) {\n    if (!hasOwn(parent, key)) {\n      mergeField(key);\n    }\n  }\n  function mergeField(key) {\n    var strat = strats[key] || defaultStrat;\n    options[key] = strat(parent[key], child[key], vm, key);\n  }\n  return options;\n}\n\n/**\n * Resolve an asset.\n * This function is used because child instances need access\n * to assets defined in its ancestor chain.\n *\n * @param {Object} options\n * @param {String} type\n * @param {String} id\n * @return {Object|Function}\n */\n\nfunction resolveAsset(options, type, id) {\n  /* istanbul ignore if */\n  if (typeof id !== 'string') {\n    return;\n  }\n  var assets = options[type];\n  var camelizedId;\n  return assets[id] ||\n  // camelCase ID\n  assets[camelizedId = camelize(id)] ||\n  // Pascal Case ID\n  assets[camelizedId.charAt(0).toUpperCase() + camelizedId.slice(1)];\n}\n\n/**\n * Assert asset exists\n */\n\nfunction assertAsset(val, type, id) {\n  if (!val) {\n    process.env.NODE_ENV !== 'production' && warn('Failed to resolve ' + type + ': ' + id);\n  }\n}\n\nvar uid$1 = 0;\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n *\n * @constructor\n */\nfunction Dep() {\n  this.id = uid$1++;\n  this.subs = [];\n}\n\n// the current target watcher being evaluated.\n// this is globally unique because there could be only one\n// watcher being evaluated at any time.\nDep.target = null;\n\n/**\n * Add a directive subscriber.\n *\n * @param {Directive} sub\n */\n\nDep.prototype.addSub = function (sub) {\n  this.subs.push(sub);\n};\n\n/**\n * Remove a directive subscriber.\n *\n * @param {Directive} sub\n */\n\nDep.prototype.removeSub = function (sub) {\n  this.subs.$remove(sub);\n};\n\n/**\n * Add self as a dependency to the target watcher.\n */\n\nDep.prototype.depend = function () {\n  Dep.target.addDep(this);\n};\n\n/**\n * Notify all subscribers of a new value.\n */\n\nDep.prototype.notify = function () {\n  // stablize the subscriber list first\n  var subs = toArray(this.subs);\n  for (var i = 0, l = subs.length; i < l; i++) {\n    subs[i].update();\n  }\n};\n\nvar arrayProto = Array.prototype;\nvar arrayMethods = Object.create(arrayProto)\n\n/**\n * Intercept mutating methods and emit events\n */\n\n;['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'].forEach(function (method) {\n  // cache original method\n  var original = arrayProto[method];\n  def(arrayMethods, method, function mutator() {\n    // avoid leaking arguments:\n    // http://jsperf.com/closure-with-arguments\n    var i = arguments.length;\n    var args = new Array(i);\n    while (i--) {\n      args[i] = arguments[i];\n    }\n    var result = original.apply(this, args);\n    var ob = this.__ob__;\n    var inserted;\n    switch (method) {\n      case 'push':\n        inserted = args;\n        break;\n      case 'unshift':\n        inserted = args;\n        break;\n      case 'splice':\n        inserted = args.slice(2);\n        break;\n    }\n    if (inserted) ob.observeArray(inserted);\n    // notify change\n    ob.dep.notify();\n    return result;\n  });\n});\n\n/**\n * Swap the element at the given index with a new value\n * and emits corresponding event.\n *\n * @param {Number} index\n * @param {*} val\n * @return {*} - replaced element\n */\n\ndef(arrayProto, '$set', function $set(index, val) {\n  if (index >= this.length) {\n    this.length = Number(index) + 1;\n  }\n  return this.splice(index, 1, val)[0];\n});\n\n/**\n * Convenience method to remove the element at given index.\n *\n * @param {Number} index\n * @param {*} val\n */\n\ndef(arrayProto, '$remove', function $remove(item) {\n  /* istanbul ignore if */\n  if (!this.length) return;\n  var index = indexOf(this, item);\n  if (index > -1) {\n    return this.splice(index, 1);\n  }\n});\n\nvar arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n/**\n * Observer class that are attached to each observed\n * object. Once attached, the observer converts target\n * object's property keys into getter/setters that\n * collect dependencies and dispatches updates.\n *\n * @param {Array|Object} value\n * @constructor\n */\n\nfunction Observer(value) {\n  this.value = value;\n  this.dep = new Dep();\n  def(value, '__ob__', this);\n  if (isArray(value)) {\n    var augment = hasProto ? protoAugment : copyAugment;\n    augment(value, arrayMethods, arrayKeys);\n    this.observeArray(value);\n  } else {\n    this.walk(value);\n  }\n}\n\n// Instance methods\n\n/**\n * Walk through each property and convert them into\n * getter/setters. This method should only be called when\n * value type is Object.\n *\n * @param {Object} obj\n */\n\nObserver.prototype.walk = function (obj) {\n  var keys = Object.keys(obj);\n  for (var i = 0, l = keys.length; i < l; i++) {\n    this.convert(keys[i], obj[keys[i]]);\n  }\n};\n\n/**\n * Observe a list of Array items.\n *\n * @param {Array} items\n */\n\nObserver.prototype.observeArray = function (items) {\n  for (var i = 0, l = items.length; i < l; i++) {\n    observe(items[i]);\n  }\n};\n\n/**\n * Convert a property into getter/setter so we can emit\n * the events when the property is accessed/changed.\n *\n * @param {String} key\n * @param {*} val\n */\n\nObserver.prototype.convert = function (key, val) {\n  defineReactive(this.value, key, val);\n};\n\n/**\n * Add an owner vm, so that when $set/$delete mutations\n * happen we can notify owner vms to proxy the keys and\n * digest the watchers. This is only called when the object\n * is observed as an instance's root $data.\n *\n * @param {Vue} vm\n */\n\nObserver.prototype.addVm = function (vm) {\n  (this.vms || (this.vms = [])).push(vm);\n};\n\n/**\n * Remove an owner vm. This is called when the object is\n * swapped out as an instance's $data object.\n *\n * @param {Vue} vm\n */\n\nObserver.prototype.removeVm = function (vm) {\n  this.vms.$remove(vm);\n};\n\n// helpers\n\n/**\n * Augment an target Object or Array by intercepting\n * the prototype chain using __proto__\n *\n * @param {Object|Array} target\n * @param {Object} proto\n */\n\nfunction protoAugment(target, src) {\n  /* eslint-disable no-proto */\n  target.__proto__ = src;\n  /* eslint-enable no-proto */\n}\n\n/**\n * Augment an target Object or Array by defining\n * hidden properties.\n *\n * @param {Object|Array} target\n * @param {Object} proto\n */\n\nfunction copyAugment(target, src, keys) {\n  for (var i = 0, l = keys.length; i < l; i++) {\n    var key = keys[i];\n    def(target, key, src[key]);\n  }\n}\n\n/**\n * Attempt to create an observer instance for a value,\n * returns the new observer if successfully observed,\n * or the existing observer if the value already has one.\n *\n * @param {*} value\n * @param {Vue} [vm]\n * @return {Observer|undefined}\n * @static\n */\n\nfunction observe(value, vm) {\n  if (!value || typeof value !== 'object') {\n    return;\n  }\n  var ob;\n  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n    ob = value.__ob__;\n  } else if ((isArray(value) || isPlainObject(value)) && Object.isExtensible(value) && !value._isVue) {\n    ob = new Observer(value);\n  }\n  if (ob && vm) {\n    ob.addVm(vm);\n  }\n  return ob;\n}\n\n/**\n * Define a reactive property on an Object.\n *\n * @param {Object} obj\n * @param {String} key\n * @param {*} val\n */\n\nfunction defineReactive(obj, key, val) {\n  var dep = new Dep();\n\n  var property = Object.getOwnPropertyDescriptor(obj, key);\n  if (property && property.configurable === false) {\n    return;\n  }\n\n  // cater for pre-defined getter/setters\n  var getter = property && property.get;\n  var setter = property && property.set;\n\n  var childOb = observe(val);\n  Object.defineProperty(obj, key, {\n    enumerable: true,\n    configurable: true,\n    get: function reactiveGetter() {\n      var value = getter ? getter.call(obj) : val;\n      if (Dep.target) {\n        dep.depend();\n        if (childOb) {\n          childOb.dep.depend();\n        }\n        if (isArray(value)) {\n          for (var e, i = 0, l = value.length; i < l; i++) {\n            e = value[i];\n            e && e.__ob__ && e.__ob__.dep.depend();\n          }\n        }\n      }\n      return value;\n    },\n    set: function reactiveSetter(newVal) {\n      var value = getter ? getter.call(obj) : val;\n      if (newVal === value) {\n        return;\n      }\n      if (setter) {\n        setter.call(obj, newVal);\n      } else {\n        val = newVal;\n      }\n      childOb = observe(newVal);\n      dep.notify();\n    }\n  });\n}\n\n\n\nvar util = Object.freeze({\n\tdefineReactive: defineReactive,\n\tset: set,\n\tdel: del,\n\thasOwn: hasOwn,\n\tisLiteral: isLiteral,\n\tisReserved: isReserved,\n\t_toString: _toString,\n\ttoNumber: toNumber,\n\ttoBoolean: toBoolean,\n\tstripQuotes: stripQuotes,\n\tcamelize: camelize,\n\thyphenate: hyphenate,\n\tclassify: classify,\n\tbind: bind,\n\ttoArray: toArray,\n\textend: extend,\n\tisObject: isObject,\n\tisPlainObject: isPlainObject,\n\tdef: def,\n\tdebounce: _debounce,\n\tindexOf: indexOf,\n\tcancellable: cancellable,\n\tlooseEqual: looseEqual,\n\tisArray: isArray,\n\thasProto: hasProto,\n\tinBrowser: inBrowser,\n\tdevtools: devtools,\n\tisIE9: isIE9,\n\tisAndroid: isAndroid,\n\tget transitionProp () { return transitionProp; },\n\tget transitionEndEvent () { return transitionEndEvent; },\n\tget animationProp () { return animationProp; },\n\tget animationEndEvent () { return animationEndEvent; },\n\tnextTick: nextTick,\n\tquery: query,\n\tinDoc: inDoc,\n\tgetAttr: getAttr,\n\tgetBindAttr: getBindAttr,\n\thasBindAttr: hasBindAttr,\n\tbefore: before,\n\tafter: after,\n\tremove: remove,\n\tprepend: prepend,\n\treplace: replace,\n\ton: on,\n\toff: off,\n\tsetClass: setClass,\n\taddClass: addClass,\n\tremoveClass: removeClass,\n\textractContent: extractContent,\n\ttrimNode: trimNode,\n\tisTemplate: isTemplate,\n\tcreateAnchor: createAnchor,\n\tfindRef: findRef,\n\tmapNodeRange: mapNodeRange,\n\tremoveNodeRange: removeNodeRange,\n\tisFragment: isFragment,\n\tgetOuterHTML: getOuterHTML,\n\tmergeOptions: mergeOptions,\n\tresolveAsset: resolveAsset,\n\tassertAsset: assertAsset,\n\tcheckComponentAttr: checkComponentAttr,\n\tinitProp: initProp,\n\tassertProp: assertProp,\n\tcoerceProp: coerceProp,\n\tcommonTagRE: commonTagRE,\n\treservedTagRE: reservedTagRE,\n\tget warn () { return warn; }\n});\n\nvar uid = 0;\n\nfunction initMixin (Vue) {\n  /**\n   * The main init sequence. This is called for every\n   * instance, including ones that are created from extended\n   * constructors.\n   *\n   * @param {Object} options - this options object should be\n   *                           the result of merging class\n   *                           options and the options passed\n   *                           in to the constructor.\n   */\n\n  Vue.prototype._init = function (options) {\n    options = options || {};\n\n    this.$el = null;\n    this.$parent = options.parent;\n    this.$root = this.$parent ? this.$parent.$root : this;\n    this.$children = [];\n    this.$refs = {}; // child vm references\n    this.$els = {}; // element references\n    this._watchers = []; // all watchers as an array\n    this._directives = []; // all directives\n\n    // a uid\n    this._uid = uid++;\n\n    // a flag to avoid this being observed\n    this._isVue = true;\n\n    // events bookkeeping\n    this._events = {}; // registered callbacks\n    this._eventsCount = {}; // for $broadcast optimization\n\n    // fragment instance properties\n    this._isFragment = false;\n    this._fragment = // @type {DocumentFragment}\n    this._fragmentStart = // @type {Text|Comment}\n    this._fragmentEnd = null; // @type {Text|Comment}\n\n    // lifecycle state\n    this._isCompiled = this._isDestroyed = this._isReady = this._isAttached = this._isBeingDestroyed = this._vForRemoving = false;\n    this._unlinkFn = null;\n\n    // context:\n    // if this is a transcluded component, context\n    // will be the common parent vm of this instance\n    // and its host.\n    this._context = options._context || this.$parent;\n\n    // scope:\n    // if this is inside an inline v-for, the scope\n    // will be the intermediate scope created for this\n    // repeat fragment. this is used for linking props\n    // and container directives.\n    this._scope = options._scope;\n\n    // fragment:\n    // if this instance is compiled inside a Fragment, it\n    // needs to reigster itself as a child of that fragment\n    // for attach/detach to work properly.\n    this._frag = options._frag;\n    if (this._frag) {\n      this._frag.children.push(this);\n    }\n\n    // push self into parent / transclusion host\n    if (this.$parent) {\n      this.$parent.$children.push(this);\n    }\n\n    // save raw constructor data before merge\n    // so that we know which properties are provided at\n    // instantiation.\n    if (process.env.NODE_ENV !== 'production') {\n      this._runtimeData = options.data;\n    }\n\n    // merge options.\n    options = this.$options = mergeOptions(this.constructor.options, options, this);\n\n    // set ref\n    this._updateRef();\n\n    // initialize data as empty object.\n    // it will be filled up in _initScope().\n    this._data = {};\n\n    // call init hook\n    this._callHook('init');\n\n    // initialize data observation and scope inheritance.\n    this._initState();\n\n    // setup event system and option events.\n    this._initEvents();\n\n    // call created hook\n    this._callHook('created');\n\n    // if `el` option is passed, start compilation.\n    if (options.el) {\n      this.$mount(options.el);\n    }\n  };\n}\n\nvar pathCache = new Cache(1000);\n\n// actions\nvar APPEND = 0;\nvar PUSH = 1;\nvar INC_SUB_PATH_DEPTH = 2;\nvar PUSH_SUB_PATH = 3;\n\n// states\nvar BEFORE_PATH = 0;\nvar IN_PATH = 1;\nvar BEFORE_IDENT = 2;\nvar IN_IDENT = 3;\nvar IN_SUB_PATH = 4;\nvar IN_SINGLE_QUOTE = 5;\nvar IN_DOUBLE_QUOTE = 6;\nvar AFTER_PATH = 7;\nvar ERROR = 8;\n\nvar pathStateMachine = [];\n\npathStateMachine[BEFORE_PATH] = {\n  'ws': [BEFORE_PATH],\n  'ident': [IN_IDENT, APPEND],\n  '[': [IN_SUB_PATH],\n  'eof': [AFTER_PATH]\n};\n\npathStateMachine[IN_PATH] = {\n  'ws': [IN_PATH],\n  '.': [BEFORE_IDENT],\n  '[': [IN_SUB_PATH],\n  'eof': [AFTER_PATH]\n};\n\npathStateMachine[BEFORE_IDENT] = {\n  'ws': [BEFORE_IDENT],\n  'ident': [IN_IDENT, APPEND]\n};\n\npathStateMachine[IN_IDENT] = {\n  'ident': [IN_IDENT, APPEND],\n  '0': [IN_IDENT, APPEND],\n  'number': [IN_IDENT, APPEND],\n  'ws': [IN_PATH, PUSH],\n  '.': [BEFORE_IDENT, PUSH],\n  '[': [IN_SUB_PATH, PUSH],\n  'eof': [AFTER_PATH, PUSH]\n};\n\npathStateMachine[IN_SUB_PATH] = {\n  \"'\": [IN_SINGLE_QUOTE, APPEND],\n  '\"': [IN_DOUBLE_QUOTE, APPEND],\n  '[': [IN_SUB_PATH, INC_SUB_PATH_DEPTH],\n  ']': [IN_PATH, PUSH_SUB_PATH],\n  'eof': ERROR,\n  'else': [IN_SUB_PATH, APPEND]\n};\n\npathStateMachine[IN_SINGLE_QUOTE] = {\n  \"'\": [IN_SUB_PATH, APPEND],\n  'eof': ERROR,\n  'else': [IN_SINGLE_QUOTE, APPEND]\n};\n\npathStateMachine[IN_DOUBLE_QUOTE] = {\n  '\"': [IN_SUB_PATH, APPEND],\n  'eof': ERROR,\n  'else': [IN_DOUBLE_QUOTE, APPEND]\n};\n\n/**\n * Determine the type of a character in a keypath.\n *\n * @param {Char} ch\n * @return {String} type\n */\n\nfunction getPathCharType(ch) {\n  if (ch === undefined) {\n    return 'eof';\n  }\n\n  var code = ch.charCodeAt(0);\n\n  switch (code) {\n    case 0x5B: // [\n    case 0x5D: // ]\n    case 0x2E: // .\n    case 0x22: // \"\n    case 0x27: // '\n    case 0x30:\n      // 0\n      return ch;\n\n    case 0x5F: // _\n    case 0x24:\n      // $\n      return 'ident';\n\n    case 0x20: // Space\n    case 0x09: // Tab\n    case 0x0A: // Newline\n    case 0x0D: // Return\n    case 0xA0: // No-break space\n    case 0xFEFF: // Byte Order Mark\n    case 0x2028: // Line Separator\n    case 0x2029:\n      // Paragraph Separator\n      return 'ws';\n  }\n\n  // a-z, A-Z\n  if (code >= 0x61 && code <= 0x7A || code >= 0x41 && code <= 0x5A) {\n    return 'ident';\n  }\n\n  // 1-9\n  if (code >= 0x31 && code <= 0x39) {\n    return 'number';\n  }\n\n  return 'else';\n}\n\n/**\n * Format a subPath, return its plain form if it is\n * a literal string or number. Otherwise prepend the\n * dynamic indicator (*).\n *\n * @param {String} path\n * @return {String}\n */\n\nfunction formatSubPath(path) {\n  var trimmed = path.trim();\n  // invalid leading 0\n  if (path.charAt(0) === '0' && isNaN(path)) {\n    return false;\n  }\n  return isLiteral(trimmed) ? stripQuotes(trimmed) : '*' + trimmed;\n}\n\n/**\n * Parse a string path into an array of segments\n *\n * @param {String} path\n * @return {Array|undefined}\n */\n\nfunction parse(path) {\n  var keys = [];\n  var index = -1;\n  var mode = BEFORE_PATH;\n  var subPathDepth = 0;\n  var c, newChar, key, type, transition, action, typeMap;\n\n  var actions = [];\n\n  actions[PUSH] = function () {\n    if (key !== undefined) {\n      keys.push(key);\n      key = undefined;\n    }\n  };\n\n  actions[APPEND] = function () {\n    if (key === undefined) {\n      key = newChar;\n    } else {\n      key += newChar;\n    }\n  };\n\n  actions[INC_SUB_PATH_DEPTH] = function () {\n    actions[APPEND]();\n    subPathDepth++;\n  };\n\n  actions[PUSH_SUB_PATH] = function () {\n    if (subPathDepth > 0) {\n      subPathDepth--;\n      mode = IN_SUB_PATH;\n      actions[APPEND]();\n    } else {\n      subPathDepth = 0;\n      key = formatSubPath(key);\n      if (key === false) {\n        return false;\n      } else {\n        actions[PUSH]();\n      }\n    }\n  };\n\n  function maybeUnescapeQuote() {\n    var nextChar = path[index + 1];\n    if (mode === IN_SINGLE_QUOTE && nextChar === \"'\" || mode === IN_DOUBLE_QUOTE && nextChar === '\"') {\n      index++;\n      newChar = '\\\\' + nextChar;\n      actions[APPEND]();\n      return true;\n    }\n  }\n\n  while (mode != null) {\n    index++;\n    c = path[index];\n\n    if (c === '\\\\' && maybeUnescapeQuote()) {\n      continue;\n    }\n\n    type = getPathCharType(c);\n    typeMap = pathStateMachine[mode];\n    transition = typeMap[type] || typeMap['else'] || ERROR;\n\n    if (transition === ERROR) {\n      return; // parse error\n    }\n\n    mode = transition[0];\n    action = actions[transition[1]];\n    if (action) {\n      newChar = transition[2];\n      newChar = newChar === undefined ? c : newChar;\n      if (action() === false) {\n        return;\n      }\n    }\n\n    if (mode === AFTER_PATH) {\n      keys.raw = path;\n      return keys;\n    }\n  }\n}\n\n/**\n * External parse that check for a cache hit first\n *\n * @param {String} path\n * @return {Array|undefined}\n */\n\nfunction parsePath(path) {\n  var hit = pathCache.get(path);\n  if (!hit) {\n    hit = parse(path);\n    if (hit) {\n      pathCache.put(path, hit);\n    }\n  }\n  return hit;\n}\n\n/**\n * Get from an object from a path string\n *\n * @param {Object} obj\n * @param {String} path\n */\n\nfunction getPath(obj, path) {\n  return parseExpression(path).get(obj);\n}\n\n/**\n * Warn against setting non-existent root path on a vm.\n */\n\nvar warnNonExistent;\nif (process.env.NODE_ENV !== 'production') {\n  warnNonExistent = function (path) {\n    warn('You are setting a non-existent path \"' + path.raw + '\" ' + 'on a vm instance. Consider pre-initializing the property ' + 'with the \"data\" option for more reliable reactivity ' + 'and better performance.');\n  };\n}\n\n/**\n * Set on an object from a path\n *\n * @param {Object} obj\n * @param {String | Array} path\n * @param {*} val\n */\n\nfunction setPath(obj, path, val) {\n  var original = obj;\n  if (typeof path === 'string') {\n    path = parse(path);\n  }\n  if (!path || !isObject(obj)) {\n    return false;\n  }\n  var last, key;\n  for (var i = 0, l = path.length; i < l; i++) {\n    last = obj;\n    key = path[i];\n    if (key.charAt(0) === '*') {\n      key = parseExpression(key.slice(1)).get.call(original, original);\n    }\n    if (i < l - 1) {\n      obj = obj[key];\n      if (!isObject(obj)) {\n        obj = {};\n        if (process.env.NODE_ENV !== 'production' && last._isVue) {\n          warnNonExistent(path);\n        }\n        set(last, key, obj);\n      }\n    } else {\n      if (isArray(obj)) {\n        obj.$set(key, val);\n      } else if (key in obj) {\n        obj[key] = val;\n      } else {\n        if (process.env.NODE_ENV !== 'production' && obj._isVue) {\n          warnNonExistent(path);\n        }\n        set(obj, key, val);\n      }\n    }\n  }\n  return true;\n}\n\nvar path = Object.freeze({\n  parsePath: parsePath,\n  getPath: getPath,\n  setPath: setPath\n});\n\nvar expressionCache = new Cache(1000);\n\nvar allowedKeywords = 'Math,Date,this,true,false,null,undefined,Infinity,NaN,' + 'isNaN,isFinite,decodeURI,decodeURIComponent,encodeURI,' + 'encodeURIComponent,parseInt,parseFloat';\nvar allowedKeywordsRE = new RegExp('^(' + allowedKeywords.replace(/,/g, '\\\\b|') + '\\\\b)');\n\n// keywords that don't make sense inside expressions\nvar improperKeywords = 'break,case,class,catch,const,continue,debugger,default,' + 'delete,do,else,export,extends,finally,for,function,if,' + 'import,in,instanceof,let,return,super,switch,throw,try,' + 'var,while,with,yield,enum,await,implements,package,' + 'proctected,static,interface,private,public';\nvar improperKeywordsRE = new RegExp('^(' + improperKeywords.replace(/,/g, '\\\\b|') + '\\\\b)');\n\nvar wsRE = /\\s/g;\nvar newlineRE = /\\n/g;\nvar saveRE = /[\\{,]\\s*[\\w\\$_]+\\s*:|('(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\]|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`)|new |typeof |void /g;\nvar restoreRE = /\"(\\d+)\"/g;\nvar pathTestRE = /^[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*|\\['.*?'\\]|\\[\".*?\"\\]|\\[\\d+\\]|\\[[A-Za-z_$][\\w$]*\\])*$/;\nvar identRE = /[^\\w$\\.](?:[A-Za-z_$][\\w$]*)/g;\nvar booleanLiteralRE = /^(?:true|false)$/;\n\n/**\n * Save / Rewrite / Restore\n *\n * When rewriting paths found in an expression, it is\n * possible for the same letter sequences to be found in\n * strings and Object literal property keys. Therefore we\n * remove and store these parts in a temporary array, and\n * restore them after the path rewrite.\n */\n\nvar saved = [];\n\n/**\n * Save replacer\n *\n * The save regex can match two possible cases:\n * 1. An opening object literal\n * 2. A string\n * If matched as a plain string, we need to escape its\n * newlines, since the string needs to be preserved when\n * generating the function body.\n *\n * @param {String} str\n * @param {String} isString - str if matched as a string\n * @return {String} - placeholder with index\n */\n\nfunction save(str, isString) {\n  var i = saved.length;\n  saved[i] = isString ? str.replace(newlineRE, '\\\\n') : str;\n  return '\"' + i + '\"';\n}\n\n/**\n * Path rewrite replacer\n *\n * @param {String} raw\n * @return {String}\n */\n\nfunction rewrite(raw) {\n  var c = raw.charAt(0);\n  var path = raw.slice(1);\n  if (allowedKeywordsRE.test(path)) {\n    return raw;\n  } else {\n    path = path.indexOf('\"') > -1 ? path.replace(restoreRE, restore) : path;\n    return c + 'scope.' + path;\n  }\n}\n\n/**\n * Restore replacer\n *\n * @param {String} str\n * @param {String} i - matched save index\n * @return {String}\n */\n\nfunction restore(str, i) {\n  return saved[i];\n}\n\n/**\n * Rewrite an expression, prefixing all path accessors with\n * `scope.` and generate getter/setter functions.\n *\n * @param {String} exp\n * @return {Function}\n */\n\nfunction compileGetter(exp) {\n  if (improperKeywordsRE.test(exp)) {\n    process.env.NODE_ENV !== 'production' && warn('Avoid using reserved keywords in expression: ' + exp);\n  }\n  // reset state\n  saved.length = 0;\n  // save strings and object literal keys\n  var body = exp.replace(saveRE, save).replace(wsRE, '');\n  // rewrite all paths\n  // pad 1 space here becaue the regex matches 1 extra char\n  body = (' ' + body).replace(identRE, rewrite).replace(restoreRE, restore);\n  return makeGetterFn(body);\n}\n\n/**\n * Build a getter function. Requires eval.\n *\n * We isolate the try/catch so it doesn't affect the\n * optimization of the parse function when it is not called.\n *\n * @param {String} body\n * @return {Function|undefined}\n */\n\nfunction makeGetterFn(body) {\n  try {\n    /* eslint-disable no-new-func */\n    return new Function('scope', 'return ' + body + ';');\n    /* eslint-enable no-new-func */\n  } catch (e) {\n    process.env.NODE_ENV !== 'production' && warn('Invalid expression. ' + 'Generated function body: ' + body);\n  }\n}\n\n/**\n * Compile a setter function for the expression.\n *\n * @param {String} exp\n * @return {Function|undefined}\n */\n\nfunction compileSetter(exp) {\n  var path = parsePath(exp);\n  if (path) {\n    return function (scope, val) {\n      setPath(scope, path, val);\n    };\n  } else {\n    process.env.NODE_ENV !== 'production' && warn('Invalid setter expression: ' + exp);\n  }\n}\n\n/**\n * Parse an expression into re-written getter/setters.\n *\n * @param {String} exp\n * @param {Boolean} needSet\n * @return {Function}\n */\n\nfunction parseExpression(exp, needSet) {\n  exp = exp.trim();\n  // try cache\n  var hit = expressionCache.get(exp);\n  if (hit) {\n    if (needSet && !hit.set) {\n      hit.set = compileSetter(hit.exp);\n    }\n    return hit;\n  }\n  var res = { exp: exp };\n  res.get = isSimplePath(exp) && exp.indexOf('[') < 0\n  // optimized super simple getter\n  ? makeGetterFn('scope.' + exp)\n  // dynamic getter\n  : compileGetter(exp);\n  if (needSet) {\n    res.set = compileSetter(exp);\n  }\n  expressionCache.put(exp, res);\n  return res;\n}\n\n/**\n * Check if an expression is a simple path.\n *\n * @param {String} exp\n * @return {Boolean}\n */\n\nfunction isSimplePath(exp) {\n  return pathTestRE.test(exp) &&\n  // don't treat true/false as paths\n  !booleanLiteralRE.test(exp) &&\n  // Math constants e.g. Math.PI, Math.E etc.\n  exp.slice(0, 5) !== 'Math.';\n}\n\nvar expression = Object.freeze({\n  parseExpression: parseExpression,\n  isSimplePath: isSimplePath\n});\n\n// we have two separate queues: one for directive updates\n// and one for user watcher registered via $watch().\n// we want to guarantee directive updates to be called\n// before user watchers so that when user watchers are\n// triggered, the DOM would have already been in updated\n// state.\nvar queue = [];\nvar userQueue = [];\nvar has = {};\nvar circular = {};\nvar waiting = false;\nvar internalQueueDepleted = false;\n\n/**\n * Reset the batcher's state.\n */\n\nfunction resetBatcherState() {\n  queue = [];\n  userQueue = [];\n  has = {};\n  circular = {};\n  waiting = internalQueueDepleted = false;\n}\n\n/**\n * Flush both queues and run the watchers.\n */\n\nfunction flushBatcherQueue() {\n  runBatcherQueue(queue);\n  internalQueueDepleted = true;\n  runBatcherQueue(userQueue);\n  // dev tool hook\n  /* istanbul ignore if */\n  if (devtools) {\n    devtools.emit('flush');\n  }\n  resetBatcherState();\n}\n\n/**\n * Run the watchers in a single queue.\n *\n * @param {Array} queue\n */\n\nfunction runBatcherQueue(queue) {\n  // do not cache length because more watchers might be pushed\n  // as we run existing watchers\n  for (var i = 0; i < queue.length; i++) {\n    var watcher = queue[i];\n    var id = watcher.id;\n    has[id] = null;\n    watcher.run();\n    // in dev build, check and stop circular updates.\n    if (process.env.NODE_ENV !== 'production' && has[id] != null) {\n      circular[id] = (circular[id] || 0) + 1;\n      if (circular[id] > config._maxUpdateCount) {\n        queue.splice(has[id], 1);\n        warn('You may have an infinite update loop for watcher ' + 'with expression: ' + watcher.expression);\n      }\n    }\n  }\n}\n\n/**\n * Push a watcher into the watcher queue.\n * Jobs with duplicate IDs will be skipped unless it's\n * pushed when the queue is being flushed.\n *\n * @param {Watcher} watcher\n *   properties:\n *   - {Number} id\n *   - {Function} run\n */\n\nfunction pushWatcher(watcher) {\n  var id = watcher.id;\n  if (has[id] == null) {\n    // if an internal watcher is pushed, but the internal\n    // queue is already depleted, we run it immediately.\n    if (internalQueueDepleted && !watcher.user) {\n      watcher.run();\n      return;\n    }\n    // push watcher into appropriate queue\n    var q = watcher.user ? userQueue : queue;\n    has[id] = q.length;\n    q.push(watcher);\n    // queue the flush\n    if (!waiting) {\n      waiting = true;\n      nextTick(flushBatcherQueue);\n    }\n  }\n}\n\nvar uid$2 = 0;\n\n/**\n * A watcher parses an expression, collects dependencies,\n * and fires callback when the expression value changes.\n * This is used for both the $watch() api and directives.\n *\n * @param {Vue} vm\n * @param {String} expression\n * @param {Function} cb\n * @param {Object} options\n *                 - {Array} filters\n *                 - {Boolean} twoWay\n *                 - {Boolean} deep\n *                 - {Boolean} user\n *                 - {Boolean} sync\n *                 - {Boolean} lazy\n *                 - {Function} [preProcess]\n *                 - {Function} [postProcess]\n * @constructor\n */\nfunction Watcher(vm, expOrFn, cb, options) {\n  // mix in options\n  if (options) {\n    extend(this, options);\n  }\n  var isFn = typeof expOrFn === 'function';\n  this.vm = vm;\n  vm._watchers.push(this);\n  this.expression = isFn ? expOrFn.toString() : expOrFn;\n  this.cb = cb;\n  this.id = ++uid$2; // uid for batching\n  this.active = true;\n  this.dirty = this.lazy; // for lazy watchers\n  this.deps = Object.create(null);\n  this.newDeps = null;\n  this.prevError = null; // for async error stacks\n  // parse expression for getter/setter\n  if (isFn) {\n    this.getter = expOrFn;\n    this.setter = undefined;\n  } else {\n    var res = parseExpression(expOrFn, this.twoWay);\n    this.getter = res.get;\n    this.setter = res.set;\n  }\n  this.value = this.lazy ? undefined : this.get();\n  // state for avoiding false triggers for deep and Array\n  // watchers during vm._digest()\n  this.queued = this.shallow = false;\n}\n\n/**\n * Add a dependency to this directive.\n *\n * @param {Dep} dep\n */\n\nWatcher.prototype.addDep = function (dep) {\n  var id = dep.id;\n  if (!this.newDeps[id]) {\n    this.newDeps[id] = dep;\n    if (!this.deps[id]) {\n      this.deps[id] = dep;\n      dep.addSub(this);\n    }\n  }\n};\n\n/**\n * Evaluate the getter, and re-collect dependencies.\n */\n\nWatcher.prototype.get = function () {\n  this.beforeGet();\n  var scope = this.scope || this.vm;\n  var value;\n  try {\n    value = this.getter.call(scope, scope);\n  } catch (e) {\n    if (process.env.NODE_ENV !== 'production' && config.warnExpressionErrors) {\n      warn('Error when evaluating expression \"' + this.expression + '\". ' + (config.debug ? '' : 'Turn on debug mode to see stack trace.'), e);\n    }\n  }\n  // \"touch\" every property so they are all tracked as\n  // dependencies for deep watching\n  if (this.deep) {\n    traverse(value);\n  }\n  if (this.preProcess) {\n    value = this.preProcess(value);\n  }\n  if (this.filters) {\n    value = scope._applyFilters(value, null, this.filters, false);\n  }\n  if (this.postProcess) {\n    value = this.postProcess(value);\n  }\n  this.afterGet();\n  return value;\n};\n\n/**\n * Set the corresponding value with the setter.\n *\n * @param {*} value\n */\n\nWatcher.prototype.set = function (value) {\n  var scope = this.scope || this.vm;\n  if (this.filters) {\n    value = scope._applyFilters(value, this.value, this.filters, true);\n  }\n  try {\n    this.setter.call(scope, scope, value);\n  } catch (e) {\n    if (process.env.NODE_ENV !== 'production' && config.warnExpressionErrors) {\n      warn('Error when evaluating setter \"' + this.expression + '\"', e);\n    }\n  }\n  // two-way sync for v-for alias\n  var forContext = scope.$forContext;\n  if (forContext && forContext.alias === this.expression) {\n    if (forContext.filters) {\n      process.env.NODE_ENV !== 'production' && warn('It seems you are using two-way binding on ' + 'a v-for alias (' + this.expression + '), and the ' + 'v-for has filters. This will not work properly. ' + 'Either remove the filters or use an array of ' + 'objects and bind to object properties instead.');\n      return;\n    }\n    forContext._withLock(function () {\n      if (scope.$key) {\n        // original is an object\n        forContext.rawValue[scope.$key] = value;\n      } else {\n        forContext.rawValue.$set(scope.$index, value);\n      }\n    });\n  }\n};\n\n/**\n * Prepare for dependency collection.\n */\n\nWatcher.prototype.beforeGet = function () {\n  Dep.target = this;\n  this.newDeps = Object.create(null);\n};\n\n/**\n * Clean up for dependency collection.\n */\n\nWatcher.prototype.afterGet = function () {\n  Dep.target = null;\n  var ids = Object.keys(this.deps);\n  var i = ids.length;\n  while (i--) {\n    var id = ids[i];\n    if (!this.newDeps[id]) {\n      this.deps[id].removeSub(this);\n    }\n  }\n  this.deps = this.newDeps;\n};\n\n/**\n * Subscriber interface.\n * Will be called when a dependency changes.\n *\n * @param {Boolean} shallow\n */\n\nWatcher.prototype.update = function (shallow) {\n  if (this.lazy) {\n    this.dirty = true;\n  } else if (this.sync || !config.async) {\n    this.run();\n  } else {\n    // if queued, only overwrite shallow with non-shallow,\n    // but not the other way around.\n    this.shallow = this.queued ? shallow ? this.shallow : false : !!shallow;\n    this.queued = true;\n    // record before-push error stack in debug mode\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production' && config.debug) {\n      this.prevError = new Error('[vue] async stack trace');\n    }\n    pushWatcher(this);\n  }\n};\n\n/**\n * Batcher job interface.\n * Will be called by the batcher.\n */\n\nWatcher.prototype.run = function () {\n  if (this.active) {\n    var value = this.get();\n    if (value !== this.value ||\n    // Deep watchers and watchers on Object/Arrays should fire even\n    // when the value is the same, because the value may\n    // have mutated; but only do so if this is a\n    // non-shallow update (caused by a vm digest).\n    (isObject(value) || this.deep) && !this.shallow) {\n      // set new value\n      var oldValue = this.value;\n      this.value = value;\n      // in debug + async mode, when a watcher callbacks\n      // throws, we also throw the saved before-push error\n      // so the full cross-tick stack trace is available.\n      var prevError = this.prevError;\n      /* istanbul ignore if */\n      if (process.env.NODE_ENV !== 'production' && config.debug && prevError) {\n        this.prevError = null;\n        try {\n          this.cb.call(this.vm, value, oldValue);\n        } catch (e) {\n          nextTick(function () {\n            throw prevError;\n          }, 0);\n          throw e;\n        }\n      } else {\n        this.cb.call(this.vm, value, oldValue);\n      }\n    }\n    this.queued = this.shallow = false;\n  }\n};\n\n/**\n * Evaluate the value of the watcher.\n * This only gets called for lazy watchers.\n */\n\nWatcher.prototype.evaluate = function () {\n  // avoid overwriting another watcher that is being\n  // collected.\n  var current = Dep.target;\n  this.value = this.get();\n  this.dirty = false;\n  Dep.target = current;\n};\n\n/**\n * Depend on all deps collected by this watcher.\n */\n\nWatcher.prototype.depend = function () {\n  var depIds = Object.keys(this.deps);\n  var i = depIds.length;\n  while (i--) {\n    this.deps[depIds[i]].depend();\n  }\n};\n\n/**\n * Remove self from all dependencies' subcriber list.\n */\n\nWatcher.prototype.teardown = function () {\n  if (this.active) {\n    // remove self from vm's watcher list\n    // this is a somewhat expensive operation so we skip it\n    // if the vm is being destroyed or is performing a v-for\n    // re-render (the watcher list is then filtered by v-for).\n    if (!this.vm._isBeingDestroyed && !this.vm._vForRemoving) {\n      this.vm._watchers.$remove(this);\n    }\n    var depIds = Object.keys(this.deps);\n    var i = depIds.length;\n    while (i--) {\n      this.deps[depIds[i]].removeSub(this);\n    }\n    this.active = false;\n    this.vm = this.cb = this.value = null;\n  }\n};\n\n/**\n * Recrusively traverse an object to evoke all converted\n * getters, so that every nested property inside the object\n * is collected as a \"deep\" dependency.\n *\n * @param {*} val\n */\n\nfunction traverse(val) {\n  var i, keys;\n  if (isArray(val)) {\n    i = val.length;\n    while (i--) traverse(val[i]);\n  } else if (isObject(val)) {\n    keys = Object.keys(val);\n    i = keys.length;\n    while (i--) traverse(val[keys[i]]);\n  }\n}\n\nvar text$1 = {\n\n  bind: function bind() {\n    this.attr = this.el.nodeType === 3 ? 'data' : 'textContent';\n  },\n\n  update: function update(value) {\n    this.el[this.attr] = _toString(value);\n  }\n};\n\nvar templateCache = new Cache(1000);\nvar idSelectorCache = new Cache(1000);\n\nvar map = {\n  efault: [0, '', ''],\n  legend: [1, '<fieldset>', '</fieldset>'],\n  tr: [2, '<table><tbody>', '</tbody></table>'],\n  col: [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>']\n};\n\nmap.td = map.th = [3, '<table><tbody><tr>', '</tr></tbody></table>'];\n\nmap.option = map.optgroup = [1, '<select multiple=\"multiple\">', '</select>'];\n\nmap.thead = map.tbody = map.colgroup = map.caption = map.tfoot = [1, '<table>', '</table>'];\n\nmap.g = map.defs = map.symbol = map.use = map.image = map.text = map.circle = map.ellipse = map.line = map.path = map.polygon = map.polyline = map.rect = [1, '<svg ' + 'xmlns=\"http://www.w3.org/2000/svg\" ' + 'xmlns:xlink=\"http://www.w3.org/1999/xlink\" ' + 'xmlns:ev=\"http://www.w3.org/2001/xml-events\"' + 'version=\"1.1\">', '</svg>'];\n\n/**\n * Check if a node is a supported template node with a\n * DocumentFragment content.\n *\n * @param {Node} node\n * @return {Boolean}\n */\n\nfunction isRealTemplate(node) {\n  return isTemplate(node) && isFragment(node.content);\n}\n\nvar tagRE$1 = /<([\\w:]+)/;\nvar entityRE = /&#?\\w+?;/;\n\n/**\n * Convert a string template to a DocumentFragment.\n * Determines correct wrapping by tag types. Wrapping\n * strategy found in jQuery & component/domify.\n *\n * @param {String} templateString\n * @param {Boolean} raw\n * @return {DocumentFragment}\n */\n\nfunction stringToFragment(templateString, raw) {\n  // try a cache hit first\n  var cacheKey = raw ? templateString : templateString.trim();\n  var hit = templateCache.get(cacheKey);\n  if (hit) {\n    return hit;\n  }\n\n  var frag = document.createDocumentFragment();\n  var tagMatch = templateString.match(tagRE$1);\n  var entityMatch = entityRE.test(templateString);\n\n  if (!tagMatch && !entityMatch) {\n    // text only, return a single text node.\n    frag.appendChild(document.createTextNode(templateString));\n  } else {\n    var tag = tagMatch && tagMatch[1];\n    var wrap = map[tag] || map.efault;\n    var depth = wrap[0];\n    var prefix = wrap[1];\n    var suffix = wrap[2];\n    var node = document.createElement('div');\n\n    node.innerHTML = prefix + templateString + suffix;\n    while (depth--) {\n      node = node.lastChild;\n    }\n\n    var child;\n    /* eslint-disable no-cond-assign */\n    while (child = node.firstChild) {\n      /* eslint-enable no-cond-assign */\n      frag.appendChild(child);\n    }\n  }\n  if (!raw) {\n    trimNode(frag);\n  }\n  templateCache.put(cacheKey, frag);\n  return frag;\n}\n\n/**\n * Convert a template node to a DocumentFragment.\n *\n * @param {Node} node\n * @return {DocumentFragment}\n */\n\nfunction nodeToFragment(node) {\n  // if its a template tag and the browser supports it,\n  // its content is already a document fragment.\n  if (isRealTemplate(node)) {\n    trimNode(node.content);\n    return node.content;\n  }\n  // script template\n  if (node.tagName === 'SCRIPT') {\n    return stringToFragment(node.textContent);\n  }\n  // normal node, clone it to avoid mutating the original\n  var clonedNode = cloneNode(node);\n  var frag = document.createDocumentFragment();\n  var child;\n  /* eslint-disable no-cond-assign */\n  while (child = clonedNode.firstChild) {\n    /* eslint-enable no-cond-assign */\n    frag.appendChild(child);\n  }\n  trimNode(frag);\n  return frag;\n}\n\n// Test for the presence of the Safari template cloning bug\n// https://bugs.webkit.org/showug.cgi?id=137755\nvar hasBrokenTemplate = (function () {\n  /* istanbul ignore else */\n  if (inBrowser) {\n    var a = document.createElement('div');\n    a.innerHTML = '<template>1</template>';\n    return !a.cloneNode(true).firstChild.innerHTML;\n  } else {\n    return false;\n  }\n})();\n\n// Test for IE10/11 textarea placeholder clone bug\nvar hasTextareaCloneBug = (function () {\n  /* istanbul ignore else */\n  if (inBrowser) {\n    var t = document.createElement('textarea');\n    t.placeholder = 't';\n    return t.cloneNode(true).value === 't';\n  } else {\n    return false;\n  }\n})();\n\n/**\n * 1. Deal with Safari cloning nested <template> bug by\n *    manually cloning all template instances.\n * 2. Deal with IE10/11 textarea placeholder bug by setting\n *    the correct value after cloning.\n *\n * @param {Element|DocumentFragment} node\n * @return {Element|DocumentFragment}\n */\n\nfunction cloneNode(node) {\n  if (!node.querySelectorAll) {\n    return node.cloneNode();\n  }\n  var res = node.cloneNode(true);\n  var i, original, cloned;\n  /* istanbul ignore if */\n  if (hasBrokenTemplate) {\n    var tempClone = res;\n    if (isRealTemplate(node)) {\n      node = node.content;\n      tempClone = res.content;\n    }\n    original = node.querySelectorAll('template');\n    if (original.length) {\n      cloned = tempClone.querySelectorAll('template');\n      i = cloned.length;\n      while (i--) {\n        cloned[i].parentNode.replaceChild(cloneNode(original[i]), cloned[i]);\n      }\n    }\n  }\n  /* istanbul ignore if */\n  if (hasTextareaCloneBug) {\n    if (node.tagName === 'TEXTAREA') {\n      res.value = node.value;\n    } else {\n      original = node.querySelectorAll('textarea');\n      if (original.length) {\n        cloned = res.querySelectorAll('textarea');\n        i = cloned.length;\n        while (i--) {\n          cloned[i].value = original[i].value;\n        }\n      }\n    }\n  }\n  return res;\n}\n\n/**\n * Process the template option and normalizes it into a\n * a DocumentFragment that can be used as a partial or a\n * instance template.\n *\n * @param {*} template\n *        Possible values include:\n *        - DocumentFragment object\n *        - Node object of type Template\n *        - id selector: '#some-template-id'\n *        - template string: '<div><span>{{msg}}</span></div>'\n * @param {Boolean} shouldClone\n * @param {Boolean} raw\n *        inline HTML interpolation. Do not check for id\n *        selector and keep whitespace in the string.\n * @return {DocumentFragment|undefined}\n */\n\nfunction parseTemplate(template, shouldClone, raw) {\n  var node, frag;\n\n  // if the template is already a document fragment,\n  // do nothing\n  if (isFragment(template)) {\n    trimNode(template);\n    return shouldClone ? cloneNode(template) : template;\n  }\n\n  if (typeof template === 'string') {\n    // id selector\n    if (!raw && template.charAt(0) === '#') {\n      // id selector can be cached too\n      frag = idSelectorCache.get(template);\n      if (!frag) {\n        node = document.getElementById(template.slice(1));\n        if (node) {\n          frag = nodeToFragment(node);\n          // save selector to cache\n          idSelectorCache.put(template, frag);\n        }\n      }\n    } else {\n      // normal string template\n      frag = stringToFragment(template, raw);\n    }\n  } else if (template.nodeType) {\n    // a direct node\n    frag = nodeToFragment(template);\n  }\n\n  return frag && shouldClone ? cloneNode(frag) : frag;\n}\n\nvar template = Object.freeze({\n  cloneNode: cloneNode,\n  parseTemplate: parseTemplate\n});\n\nvar html = {\n\n  bind: function bind() {\n    // a comment node means this is a binding for\n    // {{{ inline unescaped html }}}\n    if (this.el.nodeType === 8) {\n      // hold nodes\n      this.nodes = [];\n      // replace the placeholder with proper anchor\n      this.anchor = createAnchor('v-html');\n      replace(this.el, this.anchor);\n    }\n  },\n\n  update: function update(value) {\n    value = _toString(value);\n    if (this.nodes) {\n      this.swap(value);\n    } else {\n      this.el.innerHTML = value;\n    }\n  },\n\n  swap: function swap(value) {\n    // remove old nodes\n    var i = this.nodes.length;\n    while (i--) {\n      remove(this.nodes[i]);\n    }\n    // convert new value to a fragment\n    // do not attempt to retrieve from id selector\n    var frag = parseTemplate(value, true, true);\n    // save a reference to these nodes so we can remove later\n    this.nodes = toArray(frag.childNodes);\n    before(frag, this.anchor);\n  }\n};\n\n/**\n * Abstraction for a partially-compiled fragment.\n * Can optionally compile content with a child scope.\n *\n * @param {Function} linker\n * @param {Vue} vm\n * @param {DocumentFragment} frag\n * @param {Vue} [host]\n * @param {Object} [scope]\n */\nfunction Fragment(linker, vm, frag, host, scope, parentFrag) {\n  this.children = [];\n  this.childFrags = [];\n  this.vm = vm;\n  this.scope = scope;\n  this.inserted = false;\n  this.parentFrag = parentFrag;\n  if (parentFrag) {\n    parentFrag.childFrags.push(this);\n  }\n  this.unlink = linker(vm, frag, host, scope, this);\n  var single = this.single = frag.childNodes.length === 1 &&\n  // do not go single mode if the only node is an anchor\n  !frag.childNodes[0].__v_anchor;\n  if (single) {\n    this.node = frag.childNodes[0];\n    this.before = singleBefore;\n    this.remove = singleRemove;\n  } else {\n    this.node = createAnchor('fragment-start');\n    this.end = createAnchor('fragment-end');\n    this.frag = frag;\n    prepend(this.node, frag);\n    frag.appendChild(this.end);\n    this.before = multiBefore;\n    this.remove = multiRemove;\n  }\n  this.node.__v_frag = this;\n}\n\n/**\n * Call attach/detach for all components contained within\n * this fragment. Also do so recursively for all child\n * fragments.\n *\n * @param {Function} hook\n */\n\nFragment.prototype.callHook = function (hook) {\n  var i, l;\n  for (i = 0, l = this.childFrags.length; i < l; i++) {\n    this.childFrags[i].callHook(hook);\n  }\n  for (i = 0, l = this.children.length; i < l; i++) {\n    hook(this.children[i]);\n  }\n};\n\n/**\n * Insert fragment before target, single node version\n *\n * @param {Node} target\n * @param {Boolean} withTransition\n */\n\nfunction singleBefore(target, withTransition) {\n  this.inserted = true;\n  var method = withTransition !== false ? beforeWithTransition : before;\n  method(this.node, target, this.vm);\n  if (inDoc(this.node)) {\n    this.callHook(attach);\n  }\n}\n\n/**\n * Remove fragment, single node version\n */\n\nfunction singleRemove() {\n  this.inserted = false;\n  var shouldCallRemove = inDoc(this.node);\n  var self = this;\n  this.beforeRemove();\n  removeWithTransition(this.node, this.vm, function () {\n    if (shouldCallRemove) {\n      self.callHook(detach);\n    }\n    self.destroy();\n  });\n}\n\n/**\n * Insert fragment before target, multi-nodes version\n *\n * @param {Node} target\n * @param {Boolean} withTransition\n */\n\nfunction multiBefore(target, withTransition) {\n  this.inserted = true;\n  var vm = this.vm;\n  var method = withTransition !== false ? beforeWithTransition : before;\n  mapNodeRange(this.node, this.end, function (node) {\n    method(node, target, vm);\n  });\n  if (inDoc(this.node)) {\n    this.callHook(attach);\n  }\n}\n\n/**\n * Remove fragment, multi-nodes version\n */\n\nfunction multiRemove() {\n  this.inserted = false;\n  var self = this;\n  var shouldCallRemove = inDoc(this.node);\n  this.beforeRemove();\n  removeNodeRange(this.node, this.end, this.vm, this.frag, function () {\n    if (shouldCallRemove) {\n      self.callHook(detach);\n    }\n    self.destroy();\n  });\n}\n\n/**\n * Prepare the fragment for removal.\n */\n\nFragment.prototype.beforeRemove = function () {\n  var i, l;\n  for (i = 0, l = this.childFrags.length; i < l; i++) {\n    // call the same method recursively on child\n    // fragments, depth-first\n    this.childFrags[i].beforeRemove(false);\n  }\n  for (i = 0, l = this.children.length; i < l; i++) {\n    // Call destroy for all contained instances,\n    // with remove:false and defer:true.\n    // Defer is necessary because we need to\n    // keep the children to call detach hooks\n    // on them.\n    this.children[i].$destroy(false, true);\n  }\n  var dirs = this.unlink.dirs;\n  for (i = 0, l = dirs.length; i < l; i++) {\n    // disable the watchers on all the directives\n    // so that the rendered content stays the same\n    // during removal.\n    dirs[i]._watcher && dirs[i]._watcher.teardown();\n  }\n};\n\n/**\n * Destroy the fragment.\n */\n\nFragment.prototype.destroy = function () {\n  if (this.parentFrag) {\n    this.parentFrag.childFrags.$remove(this);\n  }\n  this.node.__v_frag = null;\n  this.unlink();\n};\n\n/**\n * Call attach hook for a Vue instance.\n *\n * @param {Vue} child\n */\n\nfunction attach(child) {\n  if (!child._isAttached) {\n    child._callHook('attached');\n  }\n}\n\n/**\n * Call detach hook for a Vue instance.\n *\n * @param {Vue} child\n */\n\nfunction detach(child) {\n  if (child._isAttached) {\n    child._callHook('detached');\n  }\n}\n\nvar linkerCache = new Cache(5000);\n\n/**\n * A factory that can be used to create instances of a\n * fragment. Caches the compiled linker if possible.\n *\n * @param {Vue} vm\n * @param {Element|String} el\n */\nfunction FragmentFactory(vm, el) {\n  this.vm = vm;\n  var template;\n  var isString = typeof el === 'string';\n  if (isString || isTemplate(el)) {\n    template = parseTemplate(el, true);\n  } else {\n    template = document.createDocumentFragment();\n    template.appendChild(el);\n  }\n  this.template = template;\n  // linker can be cached, but only for components\n  var linker;\n  var cid = vm.constructor.cid;\n  if (cid > 0) {\n    var cacheId = cid + (isString ? el : getOuterHTML(el));\n    linker = linkerCache.get(cacheId);\n    if (!linker) {\n      linker = compile(template, vm.$options, true);\n      linkerCache.put(cacheId, linker);\n    }\n  } else {\n    linker = compile(template, vm.$options, true);\n  }\n  this.linker = linker;\n}\n\n/**\n * Create a fragment instance with given host and scope.\n *\n * @param {Vue} host\n * @param {Object} scope\n * @param {Fragment} parentFrag\n */\n\nFragmentFactory.prototype.create = function (host, scope, parentFrag) {\n  var frag = cloneNode(this.template);\n  return new Fragment(this.linker, this.vm, frag, host, scope, parentFrag);\n};\n\nvar ON = 700;\nvar MODEL = 800;\nvar BIND = 850;\nvar TRANSITION = 1100;\nvar EL = 1500;\nvar COMPONENT = 1500;\nvar PARTIAL = 1750;\nvar FOR = 2000;\nvar IF = 2000;\nvar SLOT = 2100;\n\nvar uid$3 = 0;\n\nvar vFor = {\n\n  priority: FOR,\n\n  params: ['track-by', 'stagger', 'enter-stagger', 'leave-stagger'],\n\n  bind: function bind() {\n    // support \"item in/of items\" syntax\n    var inMatch = this.expression.match(/(.*) (?:in|of) (.*)/);\n    if (inMatch) {\n      var itMatch = inMatch[1].match(/\\((.*),(.*)\\)/);\n      if (itMatch) {\n        this.iterator = itMatch[1].trim();\n        this.alias = itMatch[2].trim();\n      } else {\n        this.alias = inMatch[1].trim();\n      }\n      this.expression = inMatch[2];\n    }\n\n    if (!this.alias) {\n      process.env.NODE_ENV !== 'production' && warn('Alias is required in v-for.');\n      return;\n    }\n\n    // uid as a cache identifier\n    this.id = '__v-for__' + ++uid$3;\n\n    // check if this is an option list,\n    // so that we know if we need to update the <select>'s\n    // v-model when the option list has changed.\n    // because v-model has a lower priority than v-for,\n    // the v-model is not bound here yet, so we have to\n    // retrive it in the actual updateModel() function.\n    var tag = this.el.tagName;\n    this.isOption = (tag === 'OPTION' || tag === 'OPTGROUP') && this.el.parentNode.tagName === 'SELECT';\n\n    // setup anchor nodes\n    this.start = createAnchor('v-for-start');\n    this.end = createAnchor('v-for-end');\n    replace(this.el, this.end);\n    before(this.start, this.end);\n\n    // cache\n    this.cache = Object.create(null);\n\n    // fragment factory\n    this.factory = new FragmentFactory(this.vm, this.el);\n  },\n\n  update: function update(data) {\n    this.diff(data);\n    this.updateRef();\n    this.updateModel();\n  },\n\n  /**\n   * Diff, based on new data and old data, determine the\n   * minimum amount of DOM manipulations needed to make the\n   * DOM reflect the new data Array.\n   *\n   * The algorithm diffs the new data Array by storing a\n   * hidden reference to an owner vm instance on previously\n   * seen data. This allows us to achieve O(n) which is\n   * better than a levenshtein distance based algorithm,\n   * which is O(m * n).\n   *\n   * @param {Array} data\n   */\n\n  diff: function diff(data) {\n    // check if the Array was converted from an Object\n    var item = data[0];\n    var convertedFromObject = this.fromObject = isObject(item) && hasOwn(item, '$key') && hasOwn(item, '$value');\n\n    var trackByKey = this.params.trackBy;\n    var oldFrags = this.frags;\n    var frags = this.frags = new Array(data.length);\n    var alias = this.alias;\n    var iterator = this.iterator;\n    var start = this.start;\n    var end = this.end;\n    var inDocument = inDoc(start);\n    var init = !oldFrags;\n    var i, l, frag, key, value, primitive;\n\n    // First pass, go through the new Array and fill up\n    // the new frags array. If a piece of data has a cached\n    // instance for it, we reuse it. Otherwise build a new\n    // instance.\n    for (i = 0, l = data.length; i < l; i++) {\n      item = data[i];\n      key = convertedFromObject ? item.$key : null;\n      value = convertedFromObject ? item.$value : item;\n      primitive = !isObject(value);\n      frag = !init && this.getCachedFrag(value, i, key);\n      if (frag) {\n        // reusable fragment\n        frag.reused = true;\n        // update $index\n        frag.scope.$index = i;\n        // update $key\n        if (key) {\n          frag.scope.$key = key;\n        }\n        // update iterator\n        if (iterator) {\n          frag.scope[iterator] = key !== null ? key : i;\n        }\n        // update data for track-by, object repeat &\n        // primitive values.\n        if (trackByKey || convertedFromObject || primitive) {\n          frag.scope[alias] = value;\n        }\n      } else {\n        // new isntance\n        frag = this.create(value, alias, i, key);\n        frag.fresh = !init;\n      }\n      frags[i] = frag;\n      if (init) {\n        frag.before(end);\n      }\n    }\n\n    // we're done for the initial render.\n    if (init) {\n      return;\n    }\n\n    // Second pass, go through the old fragments and\n    // destroy those who are not reused (and remove them\n    // from cache)\n    var removalIndex = 0;\n    var totalRemoved = oldFrags.length - frags.length;\n    // when removing a large number of fragments, watcher removal\n    // turns out to be a perf bottleneck, so we batch the watcher\n    // removals into a single filter call!\n    this.vm._vForRemoving = true;\n    for (i = 0, l = oldFrags.length; i < l; i++) {\n      frag = oldFrags[i];\n      if (!frag.reused) {\n        this.deleteCachedFrag(frag);\n        this.remove(frag, removalIndex++, totalRemoved, inDocument);\n      }\n    }\n    this.vm._vForRemoving = false;\n    if (removalIndex) {\n      this.vm._watchers = this.vm._watchers.filter(function (w) {\n        return w.active;\n      });\n    }\n\n    // Final pass, move/insert new fragments into the\n    // right place.\n    var targetPrev, prevEl, currentPrev;\n    var insertionIndex = 0;\n    for (i = 0, l = frags.length; i < l; i++) {\n      frag = frags[i];\n      // this is the frag that we should be after\n      targetPrev = frags[i - 1];\n      prevEl = targetPrev ? targetPrev.staggerCb ? targetPrev.staggerAnchor : targetPrev.end || targetPrev.node : start;\n      if (frag.reused && !frag.staggerCb) {\n        currentPrev = findPrevFrag(frag, start, this.id);\n        if (currentPrev !== targetPrev && (!currentPrev ||\n        // optimization for moving a single item.\n        // thanks to suggestions by @livoras in #1807\n        findPrevFrag(currentPrev, start, this.id) !== targetPrev)) {\n          this.move(frag, prevEl);\n        }\n      } else {\n        // new instance, or still in stagger.\n        // insert with updated stagger index.\n        this.insert(frag, insertionIndex++, prevEl, inDocument);\n      }\n      frag.reused = frag.fresh = false;\n    }\n  },\n\n  /**\n   * Create a new fragment instance.\n   *\n   * @param {*} value\n   * @param {String} alias\n   * @param {Number} index\n   * @param {String} [key]\n   * @return {Fragment}\n   */\n\n  create: function create(value, alias, index, key) {\n    var host = this._host;\n    // create iteration scope\n    var parentScope = this._scope || this.vm;\n    var scope = Object.create(parentScope);\n    // ref holder for the scope\n    scope.$refs = Object.create(parentScope.$refs);\n    scope.$els = Object.create(parentScope.$els);\n    // make sure point $parent to parent scope\n    scope.$parent = parentScope;\n    // for two-way binding on alias\n    scope.$forContext = this;\n    // define scope properties\n    defineReactive(scope, alias, value);\n    defineReactive(scope, '$index', index);\n    if (key) {\n      defineReactive(scope, '$key', key);\n    } else if (scope.$key) {\n      // avoid accidental fallback\n      def(scope, '$key', null);\n    }\n    if (this.iterator) {\n      defineReactive(scope, this.iterator, key !== null ? key : index);\n    }\n    var frag = this.factory.create(host, scope, this._frag);\n    frag.forId = this.id;\n    this.cacheFrag(value, frag, index, key);\n    return frag;\n  },\n\n  /**\n   * Update the v-ref on owner vm.\n   */\n\n  updateRef: function updateRef() {\n    var ref = this.descriptor.ref;\n    if (!ref) return;\n    var hash = (this._scope || this.vm).$refs;\n    var refs;\n    if (!this.fromObject) {\n      refs = this.frags.map(findVmFromFrag);\n    } else {\n      refs = {};\n      this.frags.forEach(function (frag) {\n        refs[frag.scope.$key] = findVmFromFrag(frag);\n      });\n    }\n    hash[ref] = refs;\n  },\n\n  /**\n   * For option lists, update the containing v-model on\n   * parent <select>.\n   */\n\n  updateModel: function updateModel() {\n    if (this.isOption) {\n      var parent = this.start.parentNode;\n      var model = parent && parent.__v_model;\n      if (model) {\n        model.forceUpdate();\n      }\n    }\n  },\n\n  /**\n   * Insert a fragment. Handles staggering.\n   *\n   * @param {Fragment} frag\n   * @param {Number} index\n   * @param {Node} prevEl\n   * @param {Boolean} inDocument\n   */\n\n  insert: function insert(frag, index, prevEl, inDocument) {\n    if (frag.staggerCb) {\n      frag.staggerCb.cancel();\n      frag.staggerCb = null;\n    }\n    var staggerAmount = this.getStagger(frag, index, null, 'enter');\n    if (inDocument && staggerAmount) {\n      // create an anchor and insert it synchronously,\n      // so that we can resolve the correct order without\n      // worrying about some elements not inserted yet\n      var anchor = frag.staggerAnchor;\n      if (!anchor) {\n        anchor = frag.staggerAnchor = createAnchor('stagger-anchor');\n        anchor.__v_frag = frag;\n      }\n      after(anchor, prevEl);\n      var op = frag.staggerCb = cancellable(function () {\n        frag.staggerCb = null;\n        frag.before(anchor);\n        remove(anchor);\n      });\n      setTimeout(op, staggerAmount);\n    } else {\n      frag.before(prevEl.nextSibling);\n    }\n  },\n\n  /**\n   * Remove a fragment. Handles staggering.\n   *\n   * @param {Fragment} frag\n   * @param {Number} index\n   * @param {Number} total\n   * @param {Boolean} inDocument\n   */\n\n  remove: function remove(frag, index, total, inDocument) {\n    if (frag.staggerCb) {\n      frag.staggerCb.cancel();\n      frag.staggerCb = null;\n      // it's not possible for the same frag to be removed\n      // twice, so if we have a pending stagger callback,\n      // it means this frag is queued for enter but removed\n      // before its transition started. Since it is already\n      // destroyed, we can just leave it in detached state.\n      return;\n    }\n    var staggerAmount = this.getStagger(frag, index, total, 'leave');\n    if (inDocument && staggerAmount) {\n      var op = frag.staggerCb = cancellable(function () {\n        frag.staggerCb = null;\n        frag.remove();\n      });\n      setTimeout(op, staggerAmount);\n    } else {\n      frag.remove();\n    }\n  },\n\n  /**\n   * Move a fragment to a new position.\n   * Force no transition.\n   *\n   * @param {Fragment} frag\n   * @param {Node} prevEl\n   */\n\n  move: function move(frag, prevEl) {\n    // fix a common issue with Sortable:\n    // if prevEl doesn't have nextSibling, this means it's\n    // been dragged after the end anchor. Just re-position\n    // the end anchor to the end of the container.\n    /* istanbul ignore if */\n    if (!prevEl.nextSibling) {\n      this.end.parentNode.appendChild(this.end);\n    }\n    frag.before(prevEl.nextSibling, false);\n  },\n\n  /**\n   * Cache a fragment using track-by or the object key.\n   *\n   * @param {*} value\n   * @param {Fragment} frag\n   * @param {Number} index\n   * @param {String} [key]\n   */\n\n  cacheFrag: function cacheFrag(value, frag, index, key) {\n    var trackByKey = this.params.trackBy;\n    var cache = this.cache;\n    var primitive = !isObject(value);\n    var id;\n    if (key || trackByKey || primitive) {\n      id = trackByKey ? trackByKey === '$index' ? index : value[trackByKey] : key || value;\n      if (!cache[id]) {\n        cache[id] = frag;\n      } else if (trackByKey !== '$index') {\n        process.env.NODE_ENV !== 'production' && this.warnDuplicate(value);\n      }\n    } else {\n      id = this.id;\n      if (hasOwn(value, id)) {\n        if (value[id] === null) {\n          value[id] = frag;\n        } else {\n          process.env.NODE_ENV !== 'production' && this.warnDuplicate(value);\n        }\n      } else {\n        def(value, id, frag);\n      }\n    }\n    frag.raw = value;\n  },\n\n  /**\n   * Get a cached fragment from the value/index/key\n   *\n   * @param {*} value\n   * @param {Number} index\n   * @param {String} key\n   * @return {Fragment}\n   */\n\n  getCachedFrag: function getCachedFrag(value, index, key) {\n    var trackByKey = this.params.trackBy;\n    var primitive = !isObject(value);\n    var frag;\n    if (key || trackByKey || primitive) {\n      var id = trackByKey ? trackByKey === '$index' ? index : value[trackByKey] : key || value;\n      frag = this.cache[id];\n    } else {\n      frag = value[this.id];\n    }\n    if (frag && (frag.reused || frag.fresh)) {\n      process.env.NODE_ENV !== 'production' && this.warnDuplicate(value);\n    }\n    return frag;\n  },\n\n  /**\n   * Delete a fragment from cache.\n   *\n   * @param {Fragment} frag\n   */\n\n  deleteCachedFrag: function deleteCachedFrag(frag) {\n    var value = frag.raw;\n    var trackByKey = this.params.trackBy;\n    var scope = frag.scope;\n    var index = scope.$index;\n    // fix #948: avoid accidentally fall through to\n    // a parent repeater which happens to have $key.\n    var key = hasOwn(scope, '$key') && scope.$key;\n    var primitive = !isObject(value);\n    if (trackByKey || key || primitive) {\n      var id = trackByKey ? trackByKey === '$index' ? index : value[trackByKey] : key || value;\n      this.cache[id] = null;\n    } else {\n      value[this.id] = null;\n      frag.raw = null;\n    }\n  },\n\n  /**\n   * Get the stagger amount for an insertion/removal.\n   *\n   * @param {Fragment} frag\n   * @param {Number} index\n   * @param {Number} total\n   * @param {String} type\n   */\n\n  getStagger: function getStagger(frag, index, total, type) {\n    type = type + 'Stagger';\n    var trans = frag.node.__v_trans;\n    var hooks = trans && trans.hooks;\n    var hook = hooks && (hooks[type] || hooks.stagger);\n    return hook ? hook.call(frag, index, total) : index * parseInt(this.params[type] || this.params.stagger, 10);\n  },\n\n  /**\n   * Pre-process the value before piping it through the\n   * filters. This is passed to and called by the watcher.\n   */\n\n  _preProcess: function _preProcess(value) {\n    // regardless of type, store the un-filtered raw value.\n    this.rawValue = value;\n    return value;\n  },\n\n  /**\n   * Post-process the value after it has been piped through\n   * the filters. This is passed to and called by the watcher.\n   *\n   * It is necessary for this to be called during the\n   * wathcer's dependency collection phase because we want\n   * the v-for to update when the source Object is mutated.\n   */\n\n  _postProcess: function _postProcess(value) {\n    if (isArray(value)) {\n      return value;\n    } else if (isPlainObject(value)) {\n      // convert plain object to array.\n      var keys = Object.keys(value);\n      var i = keys.length;\n      var res = new Array(i);\n      var key;\n      while (i--) {\n        key = keys[i];\n        res[i] = {\n          $key: key,\n          $value: value[key]\n        };\n      }\n      return res;\n    } else {\n      if (typeof value === 'number' && !isNaN(value)) {\n        value = range(value);\n      }\n      return value || [];\n    }\n  },\n\n  unbind: function unbind() {\n    if (this.descriptor.ref) {\n      (this._scope || this.vm).$refs[this.descriptor.ref] = null;\n    }\n    if (this.frags) {\n      var i = this.frags.length;\n      var frag;\n      while (i--) {\n        frag = this.frags[i];\n        this.deleteCachedFrag(frag);\n        frag.destroy();\n      }\n    }\n  }\n};\n\n/**\n * Helper to find the previous element that is a fragment\n * anchor. This is necessary because a destroyed frag's\n * element could still be lingering in the DOM before its\n * leaving transition finishes, but its inserted flag\n * should have been set to false so we can skip them.\n *\n * If this is a block repeat, we want to make sure we only\n * return frag that is bound to this v-for. (see #929)\n *\n * @param {Fragment} frag\n * @param {Comment|Text} anchor\n * @param {String} id\n * @return {Fragment}\n */\n\nfunction findPrevFrag(frag, anchor, id) {\n  var el = frag.node.previousSibling;\n  /* istanbul ignore if */\n  if (!el) return;\n  frag = el.__v_frag;\n  while ((!frag || frag.forId !== id || !frag.inserted) && el !== anchor) {\n    el = el.previousSibling;\n    /* istanbul ignore if */\n    if (!el) return;\n    frag = el.__v_frag;\n  }\n  return frag;\n}\n\n/**\n * Find a vm from a fragment.\n *\n * @param {Fragment} frag\n * @return {Vue|undefined}\n */\n\nfunction findVmFromFrag(frag) {\n  var node = frag.node;\n  // handle multi-node frag\n  if (frag.end) {\n    while (!node.__vue__ && node !== frag.end && node.nextSibling) {\n      node = node.nextSibling;\n    }\n  }\n  return node.__vue__;\n}\n\n/**\n * Create a range array from given number.\n *\n * @param {Number} n\n * @return {Array}\n */\n\nfunction range(n) {\n  var i = -1;\n  var ret = new Array(Math.floor(n));\n  while (++i < n) {\n    ret[i] = i;\n  }\n  return ret;\n}\n\nif (process.env.NODE_ENV !== 'production') {\n  vFor.warnDuplicate = function (value) {\n    warn('Duplicate value found in v-for=\"' + this.descriptor.raw + '\": ' + JSON.stringify(value) + '. Use track-by=\"$index\" if ' + 'you are expecting duplicate values.');\n  };\n}\n\nvar vIf = {\n\n  priority: IF,\n\n  bind: function bind() {\n    var el = this.el;\n    if (!el.__vue__) {\n      // check else block\n      var next = el.nextElementSibling;\n      if (next && getAttr(next, 'v-else') !== null) {\n        remove(next);\n        this.elseFactory = new FragmentFactory(next._context || this.vm, next);\n      }\n      // check main block\n      this.anchor = createAnchor('v-if');\n      replace(el, this.anchor);\n      this.factory = new FragmentFactory(this.vm, el);\n    } else {\n      process.env.NODE_ENV !== 'production' && warn('v-if=\"' + this.expression + '\" cannot be ' + 'used on an instance root element.');\n      this.invalid = true;\n    }\n  },\n\n  update: function update(value) {\n    if (this.invalid) return;\n    if (value) {\n      if (!this.frag) {\n        this.insert();\n      }\n    } else {\n      this.remove();\n    }\n  },\n\n  insert: function insert() {\n    if (this.elseFrag) {\n      this.elseFrag.remove();\n      this.elseFrag = null;\n    }\n    this.frag = this.factory.create(this._host, this._scope, this._frag);\n    this.frag.before(this.anchor);\n  },\n\n  remove: function remove() {\n    if (this.frag) {\n      this.frag.remove();\n      this.frag = null;\n    }\n    if (this.elseFactory && !this.elseFrag) {\n      this.elseFrag = this.elseFactory.create(this._host, this._scope, this._frag);\n      this.elseFrag.before(this.anchor);\n    }\n  },\n\n  unbind: function unbind() {\n    if (this.frag) {\n      this.frag.destroy();\n    }\n    if (this.elseFrag) {\n      this.elseFrag.destroy();\n    }\n  }\n};\n\nvar show = {\n\n  bind: function bind() {\n    // check else block\n    var next = this.el.nextElementSibling;\n    if (next && getAttr(next, 'v-else') !== null) {\n      this.elseEl = next;\n    }\n  },\n\n  update: function update(value) {\n    this.apply(this.el, value);\n    if (this.elseEl) {\n      this.apply(this.elseEl, !value);\n    }\n  },\n\n  apply: function apply(el, value) {\n    if (inDoc(el)) {\n      applyTransition(el, value ? 1 : -1, toggle, this.vm);\n    } else {\n      toggle();\n    }\n    function toggle() {\n      el.style.display = value ? '' : 'none';\n    }\n  }\n};\n\nvar text$2 = {\n\n  bind: function bind() {\n    var self = this;\n    var el = this.el;\n    var isRange = el.type === 'range';\n    var lazy = this.params.lazy;\n    var number = this.params.number;\n    var debounce = this.params.debounce;\n\n    // handle composition events.\n    //   http://blog.evanyou.me/2014/01/03/composition-event/\n    // skip this for Android because it handles composition\n    // events quite differently. Android doesn't trigger\n    // composition events for language input methods e.g.\n    // Chinese, but instead triggers them for spelling\n    // suggestions... (see Discussion/#162)\n    var composing = false;\n    if (!isAndroid && !isRange) {\n      this.on('compositionstart', function () {\n        composing = true;\n      });\n      this.on('compositionend', function () {\n        composing = false;\n        // in IE11 the \"compositionend\" event fires AFTER\n        // the \"input\" event, so the input handler is blocked\n        // at the end... have to call it here.\n        //\n        // #1327: in lazy mode this is unecessary.\n        if (!lazy) {\n          self.listener();\n        }\n      });\n    }\n\n    // prevent messing with the input when user is typing,\n    // and force update on blur.\n    this.focused = false;\n    if (!isRange && !lazy) {\n      this.on('focus', function () {\n        self.focused = true;\n      });\n      this.on('blur', function () {\n        self.focused = false;\n      });\n    }\n\n    // Now attach the main listener\n    this.listener = this.rawListener = function () {\n      if (composing || !self._bound) {\n        return;\n      }\n      var val = number || isRange ? toNumber(el.value) : el.value;\n      self.set(val);\n      // force update on next tick to avoid lock & same value\n      // also only update when user is not typing\n      nextTick(function () {\n        if (self._bound && !self.focused) {\n          self.update(self._watcher.value);\n        }\n      });\n    };\n\n    // apply debounce\n    if (debounce) {\n      this.listener = _debounce(this.listener, debounce);\n    }\n\n    // Support jQuery events, since jQuery.trigger() doesn't\n    // trigger native events in some cases and some plugins\n    // rely on $.trigger()\n    //\n    // We want to make sure if a listener is attached using\n    // jQuery, it is also removed with jQuery, that's why\n    // we do the check for each directive instance and\n    // store that check result on itself. This also allows\n    // easier test coverage control by unsetting the global\n    // jQuery variable in tests.\n    this.hasjQuery = typeof jQuery === 'function';\n    if (this.hasjQuery) {\n      var method = jQuery.fn.on ? 'on' : 'bind';\n      jQuery(el)[method]('change', this.rawListener);\n      if (!lazy) {\n        jQuery(el)[method]('input', this.listener);\n      }\n    } else {\n      this.on('change', this.rawListener);\n      if (!lazy) {\n        this.on('input', this.listener);\n      }\n    }\n\n    // IE9 doesn't fire input event on backspace/del/cut\n    if (!lazy && isIE9) {\n      this.on('cut', function () {\n        nextTick(self.listener);\n      });\n      this.on('keyup', function (e) {\n        if (e.keyCode === 46 || e.keyCode === 8) {\n          self.listener();\n        }\n      });\n    }\n\n    // set initial value if present\n    if (el.hasAttribute('value') || el.tagName === 'TEXTAREA' && el.value.trim()) {\n      this.afterBind = this.listener;\n    }\n  },\n\n  update: function update(value) {\n    this.el.value = _toString(value);\n  },\n\n  unbind: function unbind() {\n    var el = this.el;\n    if (this.hasjQuery) {\n      var method = jQuery.fn.off ? 'off' : 'unbind';\n      jQuery(el)[method]('change', this.listener);\n      jQuery(el)[method]('input', this.listener);\n    }\n  }\n};\n\nvar radio = {\n\n  bind: function bind() {\n    var self = this;\n    var el = this.el;\n\n    this.getValue = function () {\n      // value overwrite via v-bind:value\n      if (el.hasOwnProperty('_value')) {\n        return el._value;\n      }\n      var val = el.value;\n      if (self.params.number) {\n        val = toNumber(val);\n      }\n      return val;\n    };\n\n    this.listener = function () {\n      self.set(self.getValue());\n    };\n    this.on('change', this.listener);\n\n    if (el.hasAttribute('checked')) {\n      this.afterBind = this.listener;\n    }\n  },\n\n  update: function update(value) {\n    this.el.checked = looseEqual(value, this.getValue());\n  }\n};\n\nvar select = {\n\n  bind: function bind() {\n    var self = this;\n    var el = this.el;\n\n    // method to force update DOM using latest value.\n    this.forceUpdate = function () {\n      if (self._watcher) {\n        self.update(self._watcher.get());\n      }\n    };\n\n    // check if this is a multiple select\n    var multiple = this.multiple = el.hasAttribute('multiple');\n\n    // attach listener\n    this.listener = function () {\n      var value = getValue(el, multiple);\n      value = self.params.number ? isArray(value) ? value.map(toNumber) : toNumber(value) : value;\n      self.set(value);\n    };\n    this.on('change', this.listener);\n\n    // if has initial value, set afterBind\n    var initValue = getValue(el, multiple, true);\n    if (multiple && initValue.length || !multiple && initValue !== null) {\n      this.afterBind = this.listener;\n    }\n\n    // All major browsers except Firefox resets\n    // selectedIndex with value -1 to 0 when the element\n    // is appended to a new parent, therefore we have to\n    // force a DOM update whenever that happens...\n    this.vm.$on('hook:attached', this.forceUpdate);\n  },\n\n  update: function update(value) {\n    var el = this.el;\n    el.selectedIndex = -1;\n    var multi = this.multiple && isArray(value);\n    var options = el.options;\n    var i = options.length;\n    var op, val;\n    while (i--) {\n      op = options[i];\n      val = op.hasOwnProperty('_value') ? op._value : op.value;\n      /* eslint-disable eqeqeq */\n      op.selected = multi ? indexOf$1(value, val) > -1 : looseEqual(value, val);\n      /* eslint-enable eqeqeq */\n    }\n  },\n\n  unbind: function unbind() {\n    /* istanbul ignore next */\n    this.vm.$off('hook:attached', this.forceUpdate);\n  }\n};\n\n/**\n * Get select value\n *\n * @param {SelectElement} el\n * @param {Boolean} multi\n * @param {Boolean} init\n * @return {Array|*}\n */\n\nfunction getValue(el, multi, init) {\n  var res = multi ? [] : null;\n  var op, val, selected;\n  for (var i = 0, l = el.options.length; i < l; i++) {\n    op = el.options[i];\n    selected = init ? op.hasAttribute('selected') : op.selected;\n    if (selected) {\n      val = op.hasOwnProperty('_value') ? op._value : op.value;\n      if (multi) {\n        res.push(val);\n      } else {\n        return val;\n      }\n    }\n  }\n  return res;\n}\n\n/**\n * Native Array.indexOf uses strict equal, but in this\n * case we need to match string/numbers with custom equal.\n *\n * @param {Array} arr\n * @param {*} val\n */\n\nfunction indexOf$1(arr, val) {\n  var i = arr.length;\n  while (i--) {\n    if (looseEqual(arr[i], val)) {\n      return i;\n    }\n  }\n  return -1;\n}\n\nvar checkbox = {\n\n  bind: function bind() {\n    var self = this;\n    var el = this.el;\n\n    this.getValue = function () {\n      return el.hasOwnProperty('_value') ? el._value : self.params.number ? toNumber(el.value) : el.value;\n    };\n\n    function getBooleanValue() {\n      var val = el.checked;\n      if (val && el.hasOwnProperty('_trueValue')) {\n        return el._trueValue;\n      }\n      if (!val && el.hasOwnProperty('_falseValue')) {\n        return el._falseValue;\n      }\n      return val;\n    }\n\n    this.listener = function () {\n      var model = self._watcher.value;\n      if (isArray(model)) {\n        var val = self.getValue();\n        if (el.checked) {\n          if (indexOf(model, val) < 0) {\n            model.push(val);\n          }\n        } else {\n          model.$remove(val);\n        }\n      } else {\n        self.set(getBooleanValue());\n      }\n    };\n\n    this.on('change', this.listener);\n    if (el.hasAttribute('checked')) {\n      this.afterBind = this.listener;\n    }\n  },\n\n  update: function update(value) {\n    var el = this.el;\n    if (isArray(value)) {\n      el.checked = indexOf(value, this.getValue()) > -1;\n    } else {\n      if (el.hasOwnProperty('_trueValue')) {\n        el.checked = looseEqual(value, el._trueValue);\n      } else {\n        el.checked = !!value;\n      }\n    }\n  }\n};\n\nvar handlers = {\n  text: text$2,\n  radio: radio,\n  select: select,\n  checkbox: checkbox\n};\n\nvar model = {\n\n  priority: MODEL,\n  twoWay: true,\n  handlers: handlers,\n  params: ['lazy', 'number', 'debounce'],\n\n  /**\n   * Possible elements:\n   *   <select>\n   *   <textarea>\n   *   <input type=\"*\">\n   *     - text\n   *     - checkbox\n   *     - radio\n   *     - number\n   */\n\n  bind: function bind() {\n    // friendly warning...\n    this.checkFilters();\n    if (this.hasRead && !this.hasWrite) {\n      process.env.NODE_ENV !== 'production' && warn('It seems you are using a read-only filter with ' + 'v-model. You might want to use a two-way filter ' + 'to ensure correct behavior.');\n    }\n    var el = this.el;\n    var tag = el.tagName;\n    var handler;\n    if (tag === 'INPUT') {\n      handler = handlers[el.type] || handlers.text;\n    } else if (tag === 'SELECT') {\n      handler = handlers.select;\n    } else if (tag === 'TEXTAREA') {\n      handler = handlers.text;\n    } else {\n      process.env.NODE_ENV !== 'production' && warn('v-model does not support element type: ' + tag);\n      return;\n    }\n    el.__v_model = this;\n    handler.bind.call(this);\n    this.update = handler.update;\n    this._unbind = handler.unbind;\n  },\n\n  /**\n   * Check read/write filter stats.\n   */\n\n  checkFilters: function checkFilters() {\n    var filters = this.filters;\n    if (!filters) return;\n    var i = filters.length;\n    while (i--) {\n      var filter = resolveAsset(this.vm.$options, 'filters', filters[i].name);\n      if (typeof filter === 'function' || filter.read) {\n        this.hasRead = true;\n      }\n      if (filter.write) {\n        this.hasWrite = true;\n      }\n    }\n  },\n\n  unbind: function unbind() {\n    this.el.__v_model = null;\n    this._unbind && this._unbind();\n  }\n};\n\n// keyCode aliases\nvar keyCodes = {\n  esc: 27,\n  tab: 9,\n  enter: 13,\n  space: 32,\n  'delete': [8, 46],\n  up: 38,\n  left: 37,\n  right: 39,\n  down: 40\n};\n\nfunction keyFilter(handler, keys) {\n  var codes = keys.map(function (key) {\n    var charCode = key.charCodeAt(0);\n    if (charCode > 47 && charCode < 58) {\n      return parseInt(key, 10);\n    }\n    if (key.length === 1) {\n      charCode = key.toUpperCase().charCodeAt(0);\n      if (charCode > 64 && charCode < 91) {\n        return charCode;\n      }\n    }\n    return keyCodes[key];\n  });\n  codes = [].concat.apply([], codes);\n  return function keyHandler(e) {\n    if (codes.indexOf(e.keyCode) > -1) {\n      return handler.call(this, e);\n    }\n  };\n}\n\nfunction stopFilter(handler) {\n  return function stopHandler(e) {\n    e.stopPropagation();\n    return handler.call(this, e);\n  };\n}\n\nfunction preventFilter(handler) {\n  return function preventHandler(e) {\n    e.preventDefault();\n    return handler.call(this, e);\n  };\n}\n\nfunction selfFilter(handler) {\n  return function selfHandler(e) {\n    if (e.target === e.currentTarget) {\n      return handler.call(this, e);\n    }\n  };\n}\n\nvar on$1 = {\n\n  priority: ON,\n  acceptStatement: true,\n  keyCodes: keyCodes,\n\n  bind: function bind() {\n    // deal with iframes\n    if (this.el.tagName === 'IFRAME' && this.arg !== 'load') {\n      var self = this;\n      this.iframeBind = function () {\n        on(self.el.contentWindow, self.arg, self.handler, self.modifiers.capture);\n      };\n      this.on('load', this.iframeBind);\n    }\n  },\n\n  update: function update(handler) {\n    // stub a noop for v-on with no value,\n    // e.g. @mousedown.prevent\n    if (!this.descriptor.raw) {\n      handler = function () {};\n    }\n\n    if (typeof handler !== 'function') {\n      process.env.NODE_ENV !== 'production' && warn('v-on:' + this.arg + '=\"' + this.expression + '\" expects a function value, ' + 'got ' + handler);\n      return;\n    }\n\n    // apply modifiers\n    if (this.modifiers.stop) {\n      handler = stopFilter(handler);\n    }\n    if (this.modifiers.prevent) {\n      handler = preventFilter(handler);\n    }\n    if (this.modifiers.self) {\n      handler = selfFilter(handler);\n    }\n    // key filter\n    var keys = Object.keys(this.modifiers).filter(function (key) {\n      return key !== 'stop' && key !== 'prevent';\n    });\n    if (keys.length) {\n      handler = keyFilter(handler, keys);\n    }\n\n    this.reset();\n    this.handler = handler;\n\n    if (this.iframeBind) {\n      this.iframeBind();\n    } else {\n      on(this.el, this.arg, this.handler, this.modifiers.capture);\n    }\n  },\n\n  reset: function reset() {\n    var el = this.iframeBind ? this.el.contentWindow : this.el;\n    if (this.handler) {\n      off(el, this.arg, this.handler);\n    }\n  },\n\n  unbind: function unbind() {\n    this.reset();\n  }\n};\n\nvar prefixes = ['-webkit-', '-moz-', '-ms-'];\nvar camelPrefixes = ['Webkit', 'Moz', 'ms'];\nvar importantRE = /!important;?$/;\nvar propCache = Object.create(null);\n\nvar testEl = null;\n\nvar style = {\n\n  deep: true,\n\n  update: function update(value) {\n    if (typeof value === 'string') {\n      this.el.style.cssText = value;\n    } else if (isArray(value)) {\n      this.handleObject(value.reduce(extend, {}));\n    } else {\n      this.handleObject(value || {});\n    }\n  },\n\n  handleObject: function handleObject(value) {\n    // cache object styles so that only changed props\n    // are actually updated.\n    var cache = this.cache || (this.cache = {});\n    var name, val;\n    for (name in cache) {\n      if (!(name in value)) {\n        this.handleSingle(name, null);\n        delete cache[name];\n      }\n    }\n    for (name in value) {\n      val = value[name];\n      if (val !== cache[name]) {\n        cache[name] = val;\n        this.handleSingle(name, val);\n      }\n    }\n  },\n\n  handleSingle: function handleSingle(prop, value) {\n    prop = normalize(prop);\n    if (!prop) return; // unsupported prop\n    // cast possible numbers/booleans into strings\n    if (value != null) value += '';\n    if (value) {\n      var isImportant = importantRE.test(value) ? 'important' : '';\n      if (isImportant) {\n        value = value.replace(importantRE, '').trim();\n      }\n      this.el.style.setProperty(prop, value, isImportant);\n    } else {\n      this.el.style.removeProperty(prop);\n    }\n  }\n\n};\n\n/**\n * Normalize a CSS property name.\n * - cache result\n * - auto prefix\n * - camelCase -> dash-case\n *\n * @param {String} prop\n * @return {String}\n */\n\nfunction normalize(prop) {\n  if (propCache[prop]) {\n    return propCache[prop];\n  }\n  var res = prefix(prop);\n  propCache[prop] = propCache[res] = res;\n  return res;\n}\n\n/**\n * Auto detect the appropriate prefix for a CSS property.\n * https://gist.github.com/paulirish/523692\n *\n * @param {String} prop\n * @return {String}\n */\n\nfunction prefix(prop) {\n  prop = hyphenate(prop);\n  var camel = camelize(prop);\n  var upper = camel.charAt(0).toUpperCase() + camel.slice(1);\n  if (!testEl) {\n    testEl = document.createElement('div');\n  }\n  var i = prefixes.length;\n  var prefixed;\n  while (i--) {\n    prefixed = camelPrefixes[i] + upper;\n    if (prefixed in testEl.style) {\n      return prefixes[i] + prop;\n    }\n  }\n  if (camel in testEl.style) {\n    return prop;\n  }\n}\n\n// xlink\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\nvar xlinkRE = /^xlink:/;\n\n// check for attributes that prohibit interpolations\nvar disallowedInterpAttrRE = /^v-|^:|^@|^(?:is|transition|transition-mode|debounce|track-by|stagger|enter-stagger|leave-stagger)$/;\n// these attributes should also set their corresponding properties\n// because they only affect the initial state of the element\nvar attrWithPropsRE = /^(?:value|checked|selected|muted)$/;\n// these attributes expect enumrated values of \"true\" or \"false\"\n// but are not boolean attributes\nvar enumeratedAttrRE = /^(?:draggable|contenteditable|spellcheck)$/;\n\n// these attributes should set a hidden property for\n// binding v-model to object values\nvar modelProps = {\n  value: '_value',\n  'true-value': '_trueValue',\n  'false-value': '_falseValue'\n};\n\nvar bind$1 = {\n\n  priority: BIND,\n\n  bind: function bind() {\n    var attr = this.arg;\n    var tag = this.el.tagName;\n    // should be deep watch on object mode\n    if (!attr) {\n      this.deep = true;\n    }\n    // handle interpolation bindings\n    var descriptor = this.descriptor;\n    var tokens = descriptor.interp;\n    if (tokens) {\n      // handle interpolations with one-time tokens\n      if (descriptor.hasOneTime) {\n        this.expression = tokensToExp(tokens, this._scope || this.vm);\n      }\n\n      // only allow binding on native attributes\n      if (disallowedInterpAttrRE.test(attr) || attr === 'name' && (tag === 'PARTIAL' || tag === 'SLOT')) {\n        process.env.NODE_ENV !== 'production' && warn(attr + '=\"' + descriptor.raw + '\": ' + 'attribute interpolation is not allowed in Vue.js ' + 'directives and special attributes.');\n        this.el.removeAttribute(attr);\n        this.invalid = true;\n      }\n\n      /* istanbul ignore if */\n      if (process.env.NODE_ENV !== 'production') {\n        var raw = attr + '=\"' + descriptor.raw + '\": ';\n        // warn src\n        if (attr === 'src') {\n          warn(raw + 'interpolation in \"src\" attribute will cause ' + 'a 404 request. Use v-bind:src instead.');\n        }\n\n        // warn style\n        if (attr === 'style') {\n          warn(raw + 'interpolation in \"style\" attribute will cause ' + 'the attribute to be discarded in Internet Explorer. ' + 'Use v-bind:style instead.');\n        }\n      }\n    }\n  },\n\n  update: function update(value) {\n    if (this.invalid) {\n      return;\n    }\n    var attr = this.arg;\n    if (this.arg) {\n      this.handleSingle(attr, value);\n    } else {\n      this.handleObject(value || {});\n    }\n  },\n\n  // share object handler with v-bind:class\n  handleObject: style.handleObject,\n\n  handleSingle: function handleSingle(attr, value) {\n    var el = this.el;\n    var interp = this.descriptor.interp;\n    if (this.modifiers.camel) {\n      attr = camelize(attr);\n    }\n    if (!interp && attrWithPropsRE.test(attr) && attr in el) {\n      el[attr] = attr === 'value' ? value == null // IE9 will set input.value to \"null\" for null...\n      ? '' : value : value;\n    }\n    // set model props\n    var modelProp = modelProps[attr];\n    if (!interp && modelProp) {\n      el[modelProp] = value;\n      // update v-model if present\n      var model = el.__v_model;\n      if (model) {\n        model.listener();\n      }\n    }\n    // do not set value attribute for textarea\n    if (attr === 'value' && el.tagName === 'TEXTAREA') {\n      el.removeAttribute(attr);\n      return;\n    }\n    // update attribute\n    if (enumeratedAttrRE.test(attr)) {\n      el.setAttribute(attr, value ? 'true' : 'false');\n    } else if (value != null && value !== false) {\n      if (attr === 'class') {\n        // handle edge case #1960:\n        // class interpolation should not overwrite Vue transition class\n        if (el.__v_trans) {\n          value += ' ' + el.__v_trans.id + '-transition';\n        }\n        setClass(el, value);\n      } else if (xlinkRE.test(attr)) {\n        el.setAttributeNS(xlinkNS, attr, value === true ? '' : value);\n      } else {\n        el.setAttribute(attr, value === true ? '' : value);\n      }\n    } else {\n      el.removeAttribute(attr);\n    }\n  }\n};\n\nvar el = {\n\n  priority: EL,\n\n  bind: function bind() {\n    /* istanbul ignore if */\n    if (!this.arg) {\n      return;\n    }\n    var id = this.id = camelize(this.arg);\n    var refs = (this._scope || this.vm).$els;\n    if (hasOwn(refs, id)) {\n      refs[id] = this.el;\n    } else {\n      defineReactive(refs, id, this.el);\n    }\n  },\n\n  unbind: function unbind() {\n    var refs = (this._scope || this.vm).$els;\n    if (refs[this.id] === this.el) {\n      refs[this.id] = null;\n    }\n  }\n};\n\nvar ref = {\n  bind: function bind() {\n    process.env.NODE_ENV !== 'production' && warn('v-ref:' + this.arg + ' must be used on a child ' + 'component. Found on <' + this.el.tagName.toLowerCase() + '>.');\n  }\n};\n\nvar cloak = {\n  bind: function bind() {\n    var el = this.el;\n    this.vm.$once('pre-hook:compiled', function () {\n      el.removeAttribute('v-cloak');\n    });\n  }\n};\n\n// must export plain object\nvar directives = {\n  text: text$1,\n  html: html,\n  'for': vFor,\n  'if': vIf,\n  show: show,\n  model: model,\n  on: on$1,\n  bind: bind$1,\n  el: el,\n  ref: ref,\n  cloak: cloak\n};\n\nvar vClass = {\n\n  deep: true,\n\n  update: function update(value) {\n    if (value && typeof value === 'string') {\n      this.handleObject(stringToObject(value));\n    } else if (isPlainObject(value)) {\n      this.handleObject(value);\n    } else if (isArray(value)) {\n      this.handleArray(value);\n    } else {\n      this.cleanup();\n    }\n  },\n\n  handleObject: function handleObject(value) {\n    this.cleanup(value);\n    var keys = this.prevKeys = Object.keys(value);\n    for (var i = 0, l = keys.length; i < l; i++) {\n      var key = keys[i];\n      if (value[key]) {\n        addClass(this.el, key);\n      } else {\n        removeClass(this.el, key);\n      }\n    }\n  },\n\n  handleArray: function handleArray(value) {\n    this.cleanup(value);\n    for (var i = 0, l = value.length; i < l; i++) {\n      if (value[i]) {\n        addClass(this.el, value[i]);\n      }\n    }\n    this.prevKeys = value.slice();\n  },\n\n  cleanup: function cleanup(value) {\n    if (this.prevKeys) {\n      var i = this.prevKeys.length;\n      while (i--) {\n        var key = this.prevKeys[i];\n        if (key && (!value || !contains(value, key))) {\n          removeClass(this.el, key);\n        }\n      }\n    }\n  }\n};\n\nfunction stringToObject(value) {\n  var res = {};\n  var keys = value.trim().split(/\\s+/);\n  var i = keys.length;\n  while (i--) {\n    res[keys[i]] = true;\n  }\n  return res;\n}\n\nfunction contains(value, key) {\n  return isArray(value) ? value.indexOf(key) > -1 : hasOwn(value, key);\n}\n\nvar component = {\n\n  priority: COMPONENT,\n\n  params: ['keep-alive', 'transition-mode', 'inline-template'],\n\n  /**\n   * Setup. Two possible usages:\n   *\n   * - static:\n   *   <comp> or <div v-component=\"comp\">\n   *\n   * - dynamic:\n   *   <component :is=\"view\">\n   */\n\n  bind: function bind() {\n    if (!this.el.__vue__) {\n      // keep-alive cache\n      this.keepAlive = this.params.keepAlive;\n      if (this.keepAlive) {\n        this.cache = {};\n      }\n      // check inline-template\n      if (this.params.inlineTemplate) {\n        // extract inline template as a DocumentFragment\n        this.inlineTemplate = extractContent(this.el, true);\n      }\n      // component resolution related state\n      this.pendingComponentCb = this.Component = null;\n      // transition related state\n      this.pendingRemovals = 0;\n      this.pendingRemovalCb = null;\n      // create a ref anchor\n      this.anchor = createAnchor('v-component');\n      replace(this.el, this.anchor);\n      // remove is attribute.\n      // this is removed during compilation, but because compilation is\n      // cached, when the component is used elsewhere this attribute\n      // will remain at link time.\n      this.el.removeAttribute('is');\n      // remove ref, same as above\n      if (this.descriptor.ref) {\n        this.el.removeAttribute('v-ref:' + hyphenate(this.descriptor.ref));\n      }\n      // if static, build right now.\n      if (this.literal) {\n        this.setComponent(this.expression);\n      }\n    } else {\n      process.env.NODE_ENV !== 'production' && warn('cannot mount component \"' + this.expression + '\" ' + 'on already mounted element: ' + this.el);\n    }\n  },\n\n  /**\n   * Public update, called by the watcher in the dynamic\n   * literal scenario, e.g. <component :is=\"view\">\n   */\n\n  update: function update(value) {\n    if (!this.literal) {\n      this.setComponent(value);\n    }\n  },\n\n  /**\n   * Switch dynamic components. May resolve the component\n   * asynchronously, and perform transition based on\n   * specified transition mode. Accepts a few additional\n   * arguments specifically for vue-router.\n   *\n   * The callback is called when the full transition is\n   * finished.\n   *\n   * @param {String} value\n   * @param {Function} [cb]\n   */\n\n  setComponent: function setComponent(value, cb) {\n    this.invalidatePending();\n    if (!value) {\n      // just remove current\n      this.unbuild(true);\n      this.remove(this.childVM, cb);\n      this.childVM = null;\n    } else {\n      var self = this;\n      this.resolveComponent(value, function () {\n        self.mountComponent(cb);\n      });\n    }\n  },\n\n  /**\n   * Resolve the component constructor to use when creating\n   * the child vm.\n   */\n\n  resolveComponent: function resolveComponent(id, cb) {\n    var self = this;\n    this.pendingComponentCb = cancellable(function (Component) {\n      self.ComponentName = Component.options.name || id;\n      self.Component = Component;\n      cb();\n    });\n    this.vm._resolveComponent(id, this.pendingComponentCb);\n  },\n\n  /**\n   * Create a new instance using the current constructor and\n   * replace the existing instance. This method doesn't care\n   * whether the new component and the old one are actually\n   * the same.\n   *\n   * @param {Function} [cb]\n   */\n\n  mountComponent: function mountComponent(cb) {\n    // actual mount\n    this.unbuild(true);\n    var self = this;\n    var activateHooks = this.Component.options.activate;\n    var cached = this.getCached();\n    var newComponent = this.build();\n    if (activateHooks && !cached) {\n      this.waitingFor = newComponent;\n      callActivateHooks(activateHooks, newComponent, function () {\n        if (self.waitingFor !== newComponent) {\n          return;\n        }\n        self.waitingFor = null;\n        self.transition(newComponent, cb);\n      });\n    } else {\n      // update ref for kept-alive component\n      if (cached) {\n        newComponent._updateRef();\n      }\n      this.transition(newComponent, cb);\n    }\n  },\n\n  /**\n   * When the component changes or unbinds before an async\n   * constructor is resolved, we need to invalidate its\n   * pending callback.\n   */\n\n  invalidatePending: function invalidatePending() {\n    if (this.pendingComponentCb) {\n      this.pendingComponentCb.cancel();\n      this.pendingComponentCb = null;\n    }\n  },\n\n  /**\n   * Instantiate/insert a new child vm.\n   * If keep alive and has cached instance, insert that\n   * instance; otherwise build a new one and cache it.\n   *\n   * @param {Object} [extraOptions]\n   * @return {Vue} - the created instance\n   */\n\n  build: function build(extraOptions) {\n    var cached = this.getCached();\n    if (cached) {\n      return cached;\n    }\n    if (this.Component) {\n      // default options\n      var options = {\n        name: this.ComponentName,\n        el: cloneNode(this.el),\n        template: this.inlineTemplate,\n        // make sure to add the child with correct parent\n        // if this is a transcluded component, its parent\n        // should be the transclusion host.\n        parent: this._host || this.vm,\n        // if no inline-template, then the compiled\n        // linker can be cached for better performance.\n        _linkerCachable: !this.inlineTemplate,\n        _ref: this.descriptor.ref,\n        _asComponent: true,\n        _isRouterView: this._isRouterView,\n        // if this is a transcluded component, context\n        // will be the common parent vm of this instance\n        // and its host.\n        _context: this.vm,\n        // if this is inside an inline v-for, the scope\n        // will be the intermediate scope created for this\n        // repeat fragment. this is used for linking props\n        // and container directives.\n        _scope: this._scope,\n        // pass in the owner fragment of this component.\n        // this is necessary so that the fragment can keep\n        // track of its contained components in order to\n        // call attach/detach hooks for them.\n        _frag: this._frag\n      };\n      // extra options\n      // in 1.0.0 this is used by vue-router only\n      /* istanbul ignore if */\n      if (extraOptions) {\n        extend(options, extraOptions);\n      }\n      var child = new this.Component(options);\n      if (this.keepAlive) {\n        this.cache[this.Component.cid] = child;\n      }\n      /* istanbul ignore if */\n      if (process.env.NODE_ENV !== 'production' && this.el.hasAttribute('transition') && child._isFragment) {\n        warn('Transitions will not work on a fragment instance. ' + 'Template: ' + child.$options.template);\n      }\n      return child;\n    }\n  },\n\n  /**\n   * Try to get a cached instance of the current component.\n   *\n   * @return {Vue|undefined}\n   */\n\n  getCached: function getCached() {\n    return this.keepAlive && this.cache[this.Component.cid];\n  },\n\n  /**\n   * Teardown the current child, but defers cleanup so\n   * that we can separate the destroy and removal steps.\n   *\n   * @param {Boolean} defer\n   */\n\n  unbuild: function unbuild(defer) {\n    if (this.waitingFor) {\n      this.waitingFor.$destroy();\n      this.waitingFor = null;\n    }\n    var child = this.childVM;\n    if (!child || this.keepAlive) {\n      if (child) {\n        // remove ref\n        child._updateRef(true);\n      }\n      return;\n    }\n    // the sole purpose of `deferCleanup` is so that we can\n    // \"deactivate\" the vm right now and perform DOM removal\n    // later.\n    child.$destroy(false, defer);\n  },\n\n  /**\n   * Remove current destroyed child and manually do\n   * the cleanup after removal.\n   *\n   * @param {Function} cb\n   */\n\n  remove: function remove(child, cb) {\n    var keepAlive = this.keepAlive;\n    if (child) {\n      // we may have a component switch when a previous\n      // component is still being transitioned out.\n      // we want to trigger only one lastest insertion cb\n      // when the existing transition finishes. (#1119)\n      this.pendingRemovals++;\n      this.pendingRemovalCb = cb;\n      var self = this;\n      child.$remove(function () {\n        self.pendingRemovals--;\n        if (!keepAlive) child._cleanup();\n        if (!self.pendingRemovals && self.pendingRemovalCb) {\n          self.pendingRemovalCb();\n          self.pendingRemovalCb = null;\n        }\n      });\n    } else if (cb) {\n      cb();\n    }\n  },\n\n  /**\n   * Actually swap the components, depending on the\n   * transition mode. Defaults to simultaneous.\n   *\n   * @param {Vue} target\n   * @param {Function} [cb]\n   */\n\n  transition: function transition(target, cb) {\n    var self = this;\n    var current = this.childVM;\n    // for devtool inspection\n    if (process.env.NODE_ENV !== 'production') {\n      if (current) current._inactive = true;\n      target._inactive = false;\n    }\n    this.childVM = target;\n    switch (self.params.transitionMode) {\n      case 'in-out':\n        target.$before(self.anchor, function () {\n          self.remove(current, cb);\n        });\n        break;\n      case 'out-in':\n        self.remove(current, function () {\n          target.$before(self.anchor, cb);\n        });\n        break;\n      default:\n        self.remove(current);\n        target.$before(self.anchor, cb);\n    }\n  },\n\n  /**\n   * Unbind.\n   */\n\n  unbind: function unbind() {\n    this.invalidatePending();\n    // Do not defer cleanup when unbinding\n    this.unbuild();\n    // destroy all keep-alive cached instances\n    if (this.cache) {\n      for (var key in this.cache) {\n        this.cache[key].$destroy();\n      }\n      this.cache = null;\n    }\n  }\n};\n\n/**\n * Call activate hooks in order (asynchronous)\n *\n * @param {Array} hooks\n * @param {Vue} vm\n * @param {Function} cb\n */\n\nfunction callActivateHooks(hooks, vm, cb) {\n  var total = hooks.length;\n  var called = 0;\n  hooks[0].call(vm, next);\n  function next() {\n    if (++called >= total) {\n      cb();\n    } else {\n      hooks[called].call(vm, next);\n    }\n  }\n}\n\nvar bindingModes = config._propBindingModes;\n\nvar propDef = {\n\n  bind: function bind() {\n    var child = this.vm;\n    var parent = child._context;\n    // passed in from compiler directly\n    var prop = this.descriptor.prop;\n    var childKey = prop.path;\n    var parentKey = prop.parentPath;\n    var twoWay = prop.mode === bindingModes.TWO_WAY;\n\n    var parentWatcher = this.parentWatcher = new Watcher(parent, parentKey, function (val) {\n      val = coerceProp(prop, val);\n      if (assertProp(prop, val)) {\n        child[childKey] = val;\n      }\n    }, {\n      twoWay: twoWay,\n      filters: prop.filters,\n      // important: props need to be observed on the\n      // v-for scope if present\n      scope: this._scope\n    });\n\n    // set the child initial value.\n    initProp(child, prop, parentWatcher.value);\n\n    // setup two-way binding\n    if (twoWay) {\n      // important: defer the child watcher creation until\n      // the created hook (after data observation)\n      var self = this;\n      child.$once('pre-hook:created', function () {\n        self.childWatcher = new Watcher(child, childKey, function (val) {\n          parentWatcher.set(val);\n        }, {\n          // ensure sync upward before parent sync down.\n          // this is necessary in cases e.g. the child\n          // mutates a prop array, then replaces it. (#1683)\n          sync: true\n        });\n      });\n    }\n  },\n\n  unbind: function unbind() {\n    this.parentWatcher.teardown();\n    if (this.childWatcher) {\n      this.childWatcher.teardown();\n    }\n  }\n};\n\nvar queue$1 = [];\nvar queued = false;\n\n/**\n * Push a job into the queue.\n *\n * @param {Function} job\n */\n\nfunction pushJob(job) {\n  queue$1.push(job);\n  if (!queued) {\n    queued = true;\n    nextTick(flush);\n  }\n}\n\n/**\n * Flush the queue, and do one forced reflow before\n * triggering transitions.\n */\n\nfunction flush() {\n  // Force layout\n  var f = document.documentElement.offsetHeight;\n  for (var i = 0; i < queue$1.length; i++) {\n    queue$1[i]();\n  }\n  queue$1 = [];\n  queued = false;\n  // dummy return, so js linters don't complain about\n  // unused variable f\n  return f;\n}\n\nvar TYPE_TRANSITION = 'transition';\nvar TYPE_ANIMATION = 'animation';\nvar transDurationProp = transitionProp + 'Duration';\nvar animDurationProp = animationProp + 'Duration';\n\n/**\n * A Transition object that encapsulates the state and logic\n * of the transition.\n *\n * @param {Element} el\n * @param {String} id\n * @param {Object} hooks\n * @param {Vue} vm\n */\nfunction Transition(el, id, hooks, vm) {\n  this.id = id;\n  this.el = el;\n  this.enterClass = hooks && hooks.enterClass || id + '-enter';\n  this.leaveClass = hooks && hooks.leaveClass || id + '-leave';\n  this.hooks = hooks;\n  this.vm = vm;\n  // async state\n  this.pendingCssEvent = this.pendingCssCb = this.cancel = this.pendingJsCb = this.op = this.cb = null;\n  this.justEntered = false;\n  this.entered = this.left = false;\n  this.typeCache = {};\n  // check css transition type\n  this.type = hooks && hooks.type;\n  /* istanbul ignore if */\n  if (process.env.NODE_ENV !== 'production') {\n    if (this.type && this.type !== TYPE_TRANSITION && this.type !== TYPE_ANIMATION) {\n      warn('invalid CSS transition type for transition=\"' + this.id + '\": ' + this.type);\n    }\n  }\n  // bind\n  var self = this;['enterNextTick', 'enterDone', 'leaveNextTick', 'leaveDone'].forEach(function (m) {\n    self[m] = bind(self[m], self);\n  });\n}\n\nvar p$1 = Transition.prototype;\n\n/**\n * Start an entering transition.\n *\n * 1. enter transition triggered\n * 2. call beforeEnter hook\n * 3. add enter class\n * 4. insert/show element\n * 5. call enter hook (with possible explicit js callback)\n * 6. reflow\n * 7. based on transition type:\n *    - transition:\n *        remove class now, wait for transitionend,\n *        then done if there's no explicit js callback.\n *    - animation:\n *        wait for animationend, remove class,\n *        then done if there's no explicit js callback.\n *    - no css transition:\n *        done now if there's no explicit js callback.\n * 8. wait for either done or js callback, then call\n *    afterEnter hook.\n *\n * @param {Function} op - insert/show the element\n * @param {Function} [cb]\n */\n\np$1.enter = function (op, cb) {\n  this.cancelPending();\n  this.callHook('beforeEnter');\n  this.cb = cb;\n  addClass(this.el, this.enterClass);\n  op();\n  this.entered = false;\n  this.callHookWithCb('enter');\n  if (this.entered) {\n    return; // user called done synchronously.\n  }\n  this.cancel = this.hooks && this.hooks.enterCancelled;\n  pushJob(this.enterNextTick);\n};\n\n/**\n * The \"nextTick\" phase of an entering transition, which is\n * to be pushed into a queue and executed after a reflow so\n * that removing the class can trigger a CSS transition.\n */\n\np$1.enterNextTick = function () {\n  // Important hack:\n  // in Chrome, if a just-entered element is applied the\n  // leave class while its interpolated property still has\n  // a very small value (within one frame), Chrome will\n  // skip the leave transition entirely and not firing the\n  // transtionend event. Therefore we need to protected\n  // against such cases using a one-frame timeout.\n  this.justEntered = true;\n  var self = this;\n  setTimeout(function () {\n    self.justEntered = false;\n  }, 17);\n\n  var enterDone = this.enterDone;\n  var type = this.getCssTransitionType(this.enterClass);\n  if (!this.pendingJsCb) {\n    if (type === TYPE_TRANSITION) {\n      // trigger transition by removing enter class now\n      removeClass(this.el, this.enterClass);\n      this.setupCssCb(transitionEndEvent, enterDone);\n    } else if (type === TYPE_ANIMATION) {\n      this.setupCssCb(animationEndEvent, enterDone);\n    } else {\n      enterDone();\n    }\n  } else if (type === TYPE_TRANSITION) {\n    removeClass(this.el, this.enterClass);\n  }\n};\n\n/**\n * The \"cleanup\" phase of an entering transition.\n */\n\np$1.enterDone = function () {\n  this.entered = true;\n  this.cancel = this.pendingJsCb = null;\n  removeClass(this.el, this.enterClass);\n  this.callHook('afterEnter');\n  if (this.cb) this.cb();\n};\n\n/**\n * Start a leaving transition.\n *\n * 1. leave transition triggered.\n * 2. call beforeLeave hook\n * 3. add leave class (trigger css transition)\n * 4. call leave hook (with possible explicit js callback)\n * 5. reflow if no explicit js callback is provided\n * 6. based on transition type:\n *    - transition or animation:\n *        wait for end event, remove class, then done if\n *        there's no explicit js callback.\n *    - no css transition:\n *        done if there's no explicit js callback.\n * 7. wait for either done or js callback, then call\n *    afterLeave hook.\n *\n * @param {Function} op - remove/hide the element\n * @param {Function} [cb]\n */\n\np$1.leave = function (op, cb) {\n  this.cancelPending();\n  this.callHook('beforeLeave');\n  this.op = op;\n  this.cb = cb;\n  addClass(this.el, this.leaveClass);\n  this.left = false;\n  this.callHookWithCb('leave');\n  if (this.left) {\n    return; // user called done synchronously.\n  }\n  this.cancel = this.hooks && this.hooks.leaveCancelled;\n  // only need to handle leaveDone if\n  // 1. the transition is already done (synchronously called\n  //    by the user, which causes this.op set to null)\n  // 2. there's no explicit js callback\n  if (this.op && !this.pendingJsCb) {\n    // if a CSS transition leaves immediately after enter,\n    // the transitionend event never fires. therefore we\n    // detect such cases and end the leave immediately.\n    if (this.justEntered) {\n      this.leaveDone();\n    } else {\n      pushJob(this.leaveNextTick);\n    }\n  }\n};\n\n/**\n * The \"nextTick\" phase of a leaving transition.\n */\n\np$1.leaveNextTick = function () {\n  var type = this.getCssTransitionType(this.leaveClass);\n  if (type) {\n    var event = type === TYPE_TRANSITION ? transitionEndEvent : animationEndEvent;\n    this.setupCssCb(event, this.leaveDone);\n  } else {\n    this.leaveDone();\n  }\n};\n\n/**\n * The \"cleanup\" phase of a leaving transition.\n */\n\np$1.leaveDone = function () {\n  this.left = true;\n  this.cancel = this.pendingJsCb = null;\n  this.op();\n  removeClass(this.el, this.leaveClass);\n  this.callHook('afterLeave');\n  if (this.cb) this.cb();\n  this.op = null;\n};\n\n/**\n * Cancel any pending callbacks from a previously running\n * but not finished transition.\n */\n\np$1.cancelPending = function () {\n  this.op = this.cb = null;\n  var hasPending = false;\n  if (this.pendingCssCb) {\n    hasPending = true;\n    off(this.el, this.pendingCssEvent, this.pendingCssCb);\n    this.pendingCssEvent = this.pendingCssCb = null;\n  }\n  if (this.pendingJsCb) {\n    hasPending = true;\n    this.pendingJsCb.cancel();\n    this.pendingJsCb = null;\n  }\n  if (hasPending) {\n    removeClass(this.el, this.enterClass);\n    removeClass(this.el, this.leaveClass);\n  }\n  if (this.cancel) {\n    this.cancel.call(this.vm, this.el);\n    this.cancel = null;\n  }\n};\n\n/**\n * Call a user-provided synchronous hook function.\n *\n * @param {String} type\n */\n\np$1.callHook = function (type) {\n  if (this.hooks && this.hooks[type]) {\n    this.hooks[type].call(this.vm, this.el);\n  }\n};\n\n/**\n * Call a user-provided, potentially-async hook function.\n * We check for the length of arguments to see if the hook\n * expects a `done` callback. If true, the transition's end\n * will be determined by when the user calls that callback;\n * otherwise, the end is determined by the CSS transition or\n * animation.\n *\n * @param {String} type\n */\n\np$1.callHookWithCb = function (type) {\n  var hook = this.hooks && this.hooks[type];\n  if (hook) {\n    if (hook.length > 1) {\n      this.pendingJsCb = cancellable(this[type + 'Done']);\n    }\n    hook.call(this.vm, this.el, this.pendingJsCb);\n  }\n};\n\n/**\n * Get an element's transition type based on the\n * calculated styles.\n *\n * @param {String} className\n * @return {Number}\n */\n\np$1.getCssTransitionType = function (className) {\n  /* istanbul ignore if */\n  if (!transitionEndEvent ||\n  // skip CSS transitions if page is not visible -\n  // this solves the issue of transitionend events not\n  // firing until the page is visible again.\n  // pageVisibility API is supported in IE10+, same as\n  // CSS transitions.\n  document.hidden ||\n  // explicit js-only transition\n  this.hooks && this.hooks.css === false ||\n  // element is hidden\n  isHidden(this.el)) {\n    return;\n  }\n  var type = this.type || this.typeCache[className];\n  if (type) return type;\n  var inlineStyles = this.el.style;\n  var computedStyles = window.getComputedStyle(this.el);\n  var transDuration = inlineStyles[transDurationProp] || computedStyles[transDurationProp];\n  if (transDuration && transDuration !== '0s') {\n    type = TYPE_TRANSITION;\n  } else {\n    var animDuration = inlineStyles[animDurationProp] || computedStyles[animDurationProp];\n    if (animDuration && animDuration !== '0s') {\n      type = TYPE_ANIMATION;\n    }\n  }\n  if (type) {\n    this.typeCache[className] = type;\n  }\n  return type;\n};\n\n/**\n * Setup a CSS transitionend/animationend callback.\n *\n * @param {String} event\n * @param {Function} cb\n */\n\np$1.setupCssCb = function (event, cb) {\n  this.pendingCssEvent = event;\n  var self = this;\n  var el = this.el;\n  var onEnd = this.pendingCssCb = function (e) {\n    if (e.target === el) {\n      off(el, event, onEnd);\n      self.pendingCssEvent = self.pendingCssCb = null;\n      if (!self.pendingJsCb && cb) {\n        cb();\n      }\n    }\n  };\n  on(el, event, onEnd);\n};\n\n/**\n * Check if an element is hidden - in that case we can just\n * skip the transition alltogether.\n *\n * @param {Element} el\n * @return {Boolean}\n */\n\nfunction isHidden(el) {\n  if (/svg$/.test(el.namespaceURI)) {\n    // SVG elements do not have offset(Width|Height)\n    // so we need to check the client rect\n    var rect = el.getBoundingClientRect();\n    return !(rect.width || rect.height);\n  } else {\n    return !(el.offsetWidth || el.offsetHeight || el.getClientRects().length);\n  }\n}\n\nvar transition$1 = {\n\n  priority: TRANSITION,\n\n  update: function update(id, oldId) {\n    var el = this.el;\n    // resolve on owner vm\n    var hooks = resolveAsset(this.vm.$options, 'transitions', id);\n    id = id || 'v';\n    el.__v_trans = new Transition(el, id, hooks, this.vm);\n    if (oldId) {\n      removeClass(el, oldId + '-transition');\n    }\n    addClass(el, id + '-transition');\n  }\n};\n\nvar internalDirectives = {\n  style: style,\n  'class': vClass,\n  component: component,\n  prop: propDef,\n  transition: transition$1\n};\n\nvar propBindingModes = config._propBindingModes;\nvar empty = {};\n\n// regexes\nvar identRE$1 = /^[$_a-zA-Z]+[\\w$]*$/;\nvar settablePathRE = /^[A-Za-z_$][\\w$]*(\\.[A-Za-z_$][\\w$]*|\\[[^\\[\\]]+\\])*$/;\n\n/**\n * Compile props on a root element and return\n * a props link function.\n *\n * @param {Element|DocumentFragment} el\n * @param {Array} propOptions\n * @return {Function} propsLinkFn\n */\n\nfunction compileProps(el, propOptions) {\n  var props = [];\n  var names = Object.keys(propOptions);\n  var i = names.length;\n  var options, name, attr, value, path, parsed, prop;\n  while (i--) {\n    name = names[i];\n    options = propOptions[name] || empty;\n\n    if (process.env.NODE_ENV !== 'production' && name === '$data') {\n      warn('Do not use $data as prop.');\n      continue;\n    }\n\n    // props could contain dashes, which will be\n    // interpreted as minus calculations by the parser\n    // so we need to camelize the path here\n    path = camelize(name);\n    if (!identRE$1.test(path)) {\n      process.env.NODE_ENV !== 'production' && warn('Invalid prop key: \"' + name + '\". Prop keys ' + 'must be valid identifiers.');\n      continue;\n    }\n\n    prop = {\n      name: name,\n      path: path,\n      options: options,\n      mode: propBindingModes.ONE_WAY,\n      raw: null\n    };\n\n    attr = hyphenate(name);\n    // first check dynamic version\n    if ((value = getBindAttr(el, attr)) === null) {\n      if ((value = getBindAttr(el, attr + '.sync')) !== null) {\n        prop.mode = propBindingModes.TWO_WAY;\n      } else if ((value = getBindAttr(el, attr + '.once')) !== null) {\n        prop.mode = propBindingModes.ONE_TIME;\n      }\n    }\n    if (value !== null) {\n      // has dynamic binding!\n      prop.raw = value;\n      parsed = parseDirective(value);\n      value = parsed.expression;\n      prop.filters = parsed.filters;\n      // check binding type\n      if (isLiteral(value) && !parsed.filters) {\n        // for expressions containing literal numbers and\n        // booleans, there's no need to setup a prop binding,\n        // so we can optimize them as a one-time set.\n        prop.optimizedLiteral = true;\n      } else {\n        prop.dynamic = true;\n        // check non-settable path for two-way bindings\n        if (process.env.NODE_ENV !== 'production' && prop.mode === propBindingModes.TWO_WAY && !settablePathRE.test(value)) {\n          prop.mode = propBindingModes.ONE_WAY;\n          warn('Cannot bind two-way prop with non-settable ' + 'parent path: ' + value);\n        }\n      }\n      prop.parentPath = value;\n\n      // warn required two-way\n      if (process.env.NODE_ENV !== 'production' && options.twoWay && prop.mode !== propBindingModes.TWO_WAY) {\n        warn('Prop \"' + name + '\" expects a two-way binding type.');\n      }\n    } else if ((value = getAttr(el, attr)) !== null) {\n      // has literal binding!\n      prop.raw = value;\n    } else if (process.env.NODE_ENV !== 'production') {\n      // check possible camelCase prop usage\n      var lowerCaseName = path.toLowerCase();\n      value = /[A-Z\\-]/.test(name) && (el.getAttribute(lowerCaseName) || el.getAttribute(':' + lowerCaseName) || el.getAttribute('v-bind:' + lowerCaseName) || el.getAttribute(':' + lowerCaseName + '.once') || el.getAttribute('v-bind:' + lowerCaseName + '.once') || el.getAttribute(':' + lowerCaseName + '.sync') || el.getAttribute('v-bind:' + lowerCaseName + '.sync'));\n      if (value) {\n        warn('Possible usage error for prop `' + lowerCaseName + '` - ' + 'did you mean `' + attr + '`? HTML is case-insensitive, remember to use ' + 'kebab-case for props in templates.');\n      } else if (options.required) {\n        // warn missing required\n        warn('Missing required prop: ' + name);\n      }\n    }\n    // push prop\n    props.push(prop);\n  }\n  return makePropsLinkFn(props);\n}\n\n/**\n * Build a function that applies props to a vm.\n *\n * @param {Array} props\n * @return {Function} propsLinkFn\n */\n\nfunction makePropsLinkFn(props) {\n  return function propsLinkFn(vm, scope) {\n    // store resolved props info\n    vm._props = {};\n    var i = props.length;\n    var prop, path, options, value, raw;\n    while (i--) {\n      prop = props[i];\n      raw = prop.raw;\n      path = prop.path;\n      options = prop.options;\n      vm._props[path] = prop;\n      if (raw === null) {\n        // initialize absent prop\n        initProp(vm, prop, getDefault(vm, options));\n      } else if (prop.dynamic) {\n        // dynamic prop\n        if (prop.mode === propBindingModes.ONE_TIME) {\n          // one time binding\n          value = (scope || vm._context || vm).$get(prop.parentPath);\n          initProp(vm, prop, value);\n        } else {\n          if (vm._context) {\n            // dynamic binding\n            vm._bindDir({\n              name: 'prop',\n              def: propDef,\n              prop: prop\n            }, null, null, scope); // el, host, scope\n          } else {\n              // root instance\n              initProp(vm, prop, vm.$get(prop.parentPath));\n            }\n        }\n      } else if (prop.optimizedLiteral) {\n        // optimized literal, cast it and just set once\n        var stripped = stripQuotes(raw);\n        value = stripped === raw ? toBoolean(toNumber(raw)) : stripped;\n        initProp(vm, prop, value);\n      } else {\n        // string literal, but we need to cater for\n        // Boolean props with no value\n        value = options.type === Boolean && raw === '' ? true : raw;\n        initProp(vm, prop, value);\n      }\n    }\n  };\n}\n\n/**\n * Get the default value of a prop.\n *\n * @param {Vue} vm\n * @param {Object} options\n * @return {*}\n */\n\nfunction getDefault(vm, options) {\n  // no default, return undefined\n  if (!hasOwn(options, 'default')) {\n    // absent boolean value defaults to false\n    return options.type === Boolean ? false : undefined;\n  }\n  var def = options['default'];\n  // warn against non-factory defaults for Object & Array\n  if (isObject(def)) {\n    process.env.NODE_ENV !== 'production' && warn('Object/Array as default prop values will be shared ' + 'across multiple instances. Use a factory function ' + 'to return the default value instead.');\n  }\n  // call factory function for non-Function types\n  return typeof def === 'function' && options.type !== Function ? def.call(vm) : def;\n}\n\n// special binding prefixes\nvar bindRE = /^v-bind:|^:/;\nvar onRE = /^v-on:|^@/;\nvar dirAttrRE = /^v-([^:]+)(?:$|:(.*)$)/;\nvar modifierRE = /\\.[^\\.]+/g;\nvar transitionRE = /^(v-bind:|:)?transition$/;\n\n// terminal directives\nvar terminalDirectives = ['for', 'if'];\n\n// default directive priority\nvar DEFAULT_PRIORITY = 1000;\n\n/**\n * Compile a template and return a reusable composite link\n * function, which recursively contains more link functions\n * inside. This top level compile function would normally\n * be called on instance root nodes, but can also be used\n * for partial compilation if the partial argument is true.\n *\n * The returned composite link function, when called, will\n * return an unlink function that tearsdown all directives\n * created during the linking phase.\n *\n * @param {Element|DocumentFragment} el\n * @param {Object} options\n * @param {Boolean} partial\n * @return {Function}\n */\n\nfunction compile(el, options, partial) {\n  // link function for the node itself.\n  var nodeLinkFn = partial || !options._asComponent ? compileNode(el, options) : null;\n  // link function for the childNodes\n  var childLinkFn = !(nodeLinkFn && nodeLinkFn.terminal) && el.tagName !== 'SCRIPT' && el.hasChildNodes() ? compileNodeList(el.childNodes, options) : null;\n\n  /**\n   * A composite linker function to be called on a already\n   * compiled piece of DOM, which instantiates all directive\n   * instances.\n   *\n   * @param {Vue} vm\n   * @param {Element|DocumentFragment} el\n   * @param {Vue} [host] - host vm of transcluded content\n   * @param {Object} [scope] - v-for scope\n   * @param {Fragment} [frag] - link context fragment\n   * @return {Function|undefined}\n   */\n\n  return function compositeLinkFn(vm, el, host, scope, frag) {\n    // cache childNodes before linking parent, fix #657\n    var childNodes = toArray(el.childNodes);\n    // link\n    var dirs = linkAndCapture(function compositeLinkCapturer() {\n      if (nodeLinkFn) nodeLinkFn(vm, el, host, scope, frag);\n      if (childLinkFn) childLinkFn(vm, childNodes, host, scope, frag);\n    }, vm);\n    return makeUnlinkFn(vm, dirs);\n  };\n}\n\n/**\n * Apply a linker to a vm/element pair and capture the\n * directives created during the process.\n *\n * @param {Function} linker\n * @param {Vue} vm\n */\n\nfunction linkAndCapture(linker, vm) {\n  /* istanbul ignore if */\n  if (process.env.NODE_ENV === 'production') {\n    // reset directives before every capture in production\n    // mode, so that when unlinking we don't need to splice\n    // them out (which turns out to be a perf hit).\n    // they are kept in development mode because they are\n    // useful for Vue's own tests.\n    vm._directives = [];\n  }\n  var originalDirCount = vm._directives.length;\n  linker();\n  var dirs = vm._directives.slice(originalDirCount);\n  dirs.sort(directiveComparator);\n  for (var i = 0, l = dirs.length; i < l; i++) {\n    dirs[i]._bind();\n  }\n  return dirs;\n}\n\n/**\n * Directive priority sort comparator\n *\n * @param {Object} a\n * @param {Object} b\n */\n\nfunction directiveComparator(a, b) {\n  a = a.descriptor.def.priority || DEFAULT_PRIORITY;\n  b = b.descriptor.def.priority || DEFAULT_PRIORITY;\n  return a > b ? -1 : a === b ? 0 : 1;\n}\n\n/**\n * Linker functions return an unlink function that\n * tearsdown all directives instances generated during\n * the process.\n *\n * We create unlink functions with only the necessary\n * information to avoid retaining additional closures.\n *\n * @param {Vue} vm\n * @param {Array} dirs\n * @param {Vue} [context]\n * @param {Array} [contextDirs]\n * @return {Function}\n */\n\nfunction makeUnlinkFn(vm, dirs, context, contextDirs) {\n  function unlink(destroying) {\n    teardownDirs(vm, dirs, destroying);\n    if (context && contextDirs) {\n      teardownDirs(context, contextDirs);\n    }\n  }\n  // expose linked directives\n  unlink.dirs = dirs;\n  return unlink;\n}\n\n/**\n * Teardown partial linked directives.\n *\n * @param {Vue} vm\n * @param {Array} dirs\n * @param {Boolean} destroying\n */\n\nfunction teardownDirs(vm, dirs, destroying) {\n  var i = dirs.length;\n  while (i--) {\n    dirs[i]._teardown();\n    if (process.env.NODE_ENV !== 'production' && !destroying) {\n      vm._directives.$remove(dirs[i]);\n    }\n  }\n}\n\n/**\n * Compile link props on an instance.\n *\n * @param {Vue} vm\n * @param {Element} el\n * @param {Object} props\n * @param {Object} [scope]\n * @return {Function}\n */\n\nfunction compileAndLinkProps(vm, el, props, scope) {\n  var propsLinkFn = compileProps(el, props);\n  var propDirs = linkAndCapture(function () {\n    propsLinkFn(vm, scope);\n  }, vm);\n  return makeUnlinkFn(vm, propDirs);\n}\n\n/**\n * Compile the root element of an instance.\n *\n * 1. attrs on context container (context scope)\n * 2. attrs on the component template root node, if\n *    replace:true (child scope)\n *\n * If this is a fragment instance, we only need to compile 1.\n *\n * @param {Element} el\n * @param {Object} options\n * @param {Object} contextOptions\n * @return {Function}\n */\n\nfunction compileRoot(el, options, contextOptions) {\n  var containerAttrs = options._containerAttrs;\n  var replacerAttrs = options._replacerAttrs;\n  var contextLinkFn, replacerLinkFn;\n\n  // only need to compile other attributes for\n  // non-fragment instances\n  if (el.nodeType !== 11) {\n    // for components, container and replacer need to be\n    // compiled separately and linked in different scopes.\n    if (options._asComponent) {\n      // 2. container attributes\n      if (containerAttrs && contextOptions) {\n        contextLinkFn = compileDirectives(containerAttrs, contextOptions);\n      }\n      if (replacerAttrs) {\n        // 3. replacer attributes\n        replacerLinkFn = compileDirectives(replacerAttrs, options);\n      }\n    } else {\n      // non-component, just compile as a normal element.\n      replacerLinkFn = compileDirectives(el.attributes, options);\n    }\n  } else if (process.env.NODE_ENV !== 'production' && containerAttrs) {\n    // warn container directives for fragment instances\n    var names = containerAttrs.filter(function (attr) {\n      // allow vue-loader/vueify scoped css attributes\n      return attr.name.indexOf('_v-') < 0 &&\n      // allow event listeners\n      !onRE.test(attr.name) &&\n      // allow slots\n      attr.name !== 'slot';\n    }).map(function (attr) {\n      return '\"' + attr.name + '\"';\n    });\n    if (names.length) {\n      var plural = names.length > 1;\n      warn('Attribute' + (plural ? 's ' : ' ') + names.join(', ') + (plural ? ' are' : ' is') + ' ignored on component ' + '<' + options.el.tagName.toLowerCase() + '> because ' + 'the component is a fragment instance: ' + 'http://vuejs.org/guide/components.html#Fragment_Instance');\n    }\n  }\n\n  options._containerAttrs = options._replacerAttrs = null;\n  return function rootLinkFn(vm, el, scope) {\n    // link context scope dirs\n    var context = vm._context;\n    var contextDirs;\n    if (context && contextLinkFn) {\n      contextDirs = linkAndCapture(function () {\n        contextLinkFn(context, el, null, scope);\n      }, context);\n    }\n\n    // link self\n    var selfDirs = linkAndCapture(function () {\n      if (replacerLinkFn) replacerLinkFn(vm, el);\n    }, vm);\n\n    // return the unlink function that tearsdown context\n    // container directives.\n    return makeUnlinkFn(vm, selfDirs, context, contextDirs);\n  };\n}\n\n/**\n * Compile a node and return a nodeLinkFn based on the\n * node type.\n *\n * @param {Node} node\n * @param {Object} options\n * @return {Function|null}\n */\n\nfunction compileNode(node, options) {\n  var type = node.nodeType;\n  if (type === 1 && node.tagName !== 'SCRIPT') {\n    return compileElement(node, options);\n  } else if (type === 3 && node.data.trim()) {\n    return compileTextNode(node, options);\n  } else {\n    return null;\n  }\n}\n\n/**\n * Compile an element and return a nodeLinkFn.\n *\n * @param {Element} el\n * @param {Object} options\n * @return {Function|null}\n */\n\nfunction compileElement(el, options) {\n  // preprocess textareas.\n  // textarea treats its text content as the initial value.\n  // just bind it as an attr directive for value.\n  if (el.tagName === 'TEXTAREA') {\n    var tokens = parseText(el.value);\n    if (tokens) {\n      el.setAttribute(':value', tokensToExp(tokens));\n      el.value = '';\n    }\n  }\n  var linkFn;\n  var hasAttrs = el.hasAttributes();\n  // check terminal directives (for & if)\n  if (hasAttrs) {\n    linkFn = checkTerminalDirectives(el, options);\n  }\n  // check element directives\n  if (!linkFn) {\n    linkFn = checkElementDirectives(el, options);\n  }\n  // check component\n  if (!linkFn) {\n    linkFn = checkComponent(el, options);\n  }\n  // normal directives\n  if (!linkFn && hasAttrs) {\n    linkFn = compileDirectives(el.attributes, options);\n  }\n  return linkFn;\n}\n\n/**\n * Compile a textNode and return a nodeLinkFn.\n *\n * @param {TextNode} node\n * @param {Object} options\n * @return {Function|null} textNodeLinkFn\n */\n\nfunction compileTextNode(node, options) {\n  // skip marked text nodes\n  if (node._skip) {\n    return removeText;\n  }\n\n  var tokens = parseText(node.wholeText);\n  if (!tokens) {\n    return null;\n  }\n\n  // mark adjacent text nodes as skipped,\n  // because we are using node.wholeText to compile\n  // all adjacent text nodes together. This fixes\n  // issues in IE where sometimes it splits up a single\n  // text node into multiple ones.\n  var next = node.nextSibling;\n  while (next && next.nodeType === 3) {\n    next._skip = true;\n    next = next.nextSibling;\n  }\n\n  var frag = document.createDocumentFragment();\n  var el, token;\n  for (var i = 0, l = tokens.length; i < l; i++) {\n    token = tokens[i];\n    el = token.tag ? processTextToken(token, options) : document.createTextNode(token.value);\n    frag.appendChild(el);\n  }\n  return makeTextNodeLinkFn(tokens, frag, options);\n}\n\n/**\n * Linker for an skipped text node.\n *\n * @param {Vue} vm\n * @param {Text} node\n */\n\nfunction removeText(vm, node) {\n  remove(node);\n}\n\n/**\n * Process a single text token.\n *\n * @param {Object} token\n * @param {Object} options\n * @return {Node}\n */\n\nfunction processTextToken(token, options) {\n  var el;\n  if (token.oneTime) {\n    el = document.createTextNode(token.value);\n  } else {\n    if (token.html) {\n      el = document.createComment('v-html');\n      setTokenType('html');\n    } else {\n      // IE will clean up empty textNodes during\n      // frag.cloneNode(true), so we have to give it\n      // something here...\n      el = document.createTextNode(' ');\n      setTokenType('text');\n    }\n  }\n  function setTokenType(type) {\n    if (token.descriptor) return;\n    var parsed = parseDirective(token.value);\n    token.descriptor = {\n      name: type,\n      def: directives[type],\n      expression: parsed.expression,\n      filters: parsed.filters\n    };\n  }\n  return el;\n}\n\n/**\n * Build a function that processes a textNode.\n *\n * @param {Array<Object>} tokens\n * @param {DocumentFragment} frag\n */\n\nfunction makeTextNodeLinkFn(tokens, frag) {\n  return function textNodeLinkFn(vm, el, host, scope) {\n    var fragClone = frag.cloneNode(true);\n    var childNodes = toArray(fragClone.childNodes);\n    var token, value, node;\n    for (var i = 0, l = tokens.length; i < l; i++) {\n      token = tokens[i];\n      value = token.value;\n      if (token.tag) {\n        node = childNodes[i];\n        if (token.oneTime) {\n          value = (scope || vm).$eval(value);\n          if (token.html) {\n            replace(node, parseTemplate(value, true));\n          } else {\n            node.data = value;\n          }\n        } else {\n          vm._bindDir(token.descriptor, node, host, scope);\n        }\n      }\n    }\n    replace(el, fragClone);\n  };\n}\n\n/**\n * Compile a node list and return a childLinkFn.\n *\n * @param {NodeList} nodeList\n * @param {Object} options\n * @return {Function|undefined}\n */\n\nfunction compileNodeList(nodeList, options) {\n  var linkFns = [];\n  var nodeLinkFn, childLinkFn, node;\n  for (var i = 0, l = nodeList.length; i < l; i++) {\n    node = nodeList[i];\n    nodeLinkFn = compileNode(node, options);\n    childLinkFn = !(nodeLinkFn && nodeLinkFn.terminal) && node.tagName !== 'SCRIPT' && node.hasChildNodes() ? compileNodeList(node.childNodes, options) : null;\n    linkFns.push(nodeLinkFn, childLinkFn);\n  }\n  return linkFns.length ? makeChildLinkFn(linkFns) : null;\n}\n\n/**\n * Make a child link function for a node's childNodes.\n *\n * @param {Array<Function>} linkFns\n * @return {Function} childLinkFn\n */\n\nfunction makeChildLinkFn(linkFns) {\n  return function childLinkFn(vm, nodes, host, scope, frag) {\n    var node, nodeLinkFn, childrenLinkFn;\n    for (var i = 0, n = 0, l = linkFns.length; i < l; n++) {\n      node = nodes[n];\n      nodeLinkFn = linkFns[i++];\n      childrenLinkFn = linkFns[i++];\n      // cache childNodes before linking parent, fix #657\n      var childNodes = toArray(node.childNodes);\n      if (nodeLinkFn) {\n        nodeLinkFn(vm, node, host, scope, frag);\n      }\n      if (childrenLinkFn) {\n        childrenLinkFn(vm, childNodes, host, scope, frag);\n      }\n    }\n  };\n}\n\n/**\n * Check for element directives (custom elements that should\n * be resovled as terminal directives).\n *\n * @param {Element} el\n * @param {Object} options\n */\n\nfunction checkElementDirectives(el, options) {\n  var tag = el.tagName.toLowerCase();\n  if (commonTagRE.test(tag)) {\n    return;\n  }\n  var def = resolveAsset(options, 'elementDirectives', tag);\n  if (def) {\n    return makeTerminalNodeLinkFn(el, tag, '', options, def);\n  }\n}\n\n/**\n * Check if an element is a component. If yes, return\n * a component link function.\n *\n * @param {Element} el\n * @param {Object} options\n * @return {Function|undefined}\n */\n\nfunction checkComponent(el, options) {\n  var component = checkComponentAttr(el, options);\n  if (component) {\n    var ref = findRef(el);\n    var descriptor = {\n      name: 'component',\n      ref: ref,\n      expression: component.id,\n      def: internalDirectives.component,\n      modifiers: {\n        literal: !component.dynamic\n      }\n    };\n    var componentLinkFn = function componentLinkFn(vm, el, host, scope, frag) {\n      if (ref) {\n        defineReactive((scope || vm).$refs, ref, null);\n      }\n      vm._bindDir(descriptor, el, host, scope, frag);\n    };\n    componentLinkFn.terminal = true;\n    return componentLinkFn;\n  }\n}\n\n/**\n * Check an element for terminal directives in fixed order.\n * If it finds one, return a terminal link function.\n *\n * @param {Element} el\n * @param {Object} options\n * @return {Function} terminalLinkFn\n */\n\nfunction checkTerminalDirectives(el, options) {\n  // skip v-pre\n  if (getAttr(el, 'v-pre') !== null) {\n    return skip;\n  }\n  // skip v-else block, but only if following v-if\n  if (el.hasAttribute('v-else')) {\n    var prev = el.previousElementSibling;\n    if (prev && prev.hasAttribute('v-if')) {\n      return skip;\n    }\n  }\n  var value, dirName;\n  for (var i = 0, l = terminalDirectives.length; i < l; i++) {\n    dirName = terminalDirectives[i];\n    value = el.getAttribute('v-' + dirName);\n    if (value != null) {\n      return makeTerminalNodeLinkFn(el, dirName, value, options);\n    }\n  }\n}\n\nfunction skip() {}\nskip.terminal = true;\n\n/**\n * Build a node link function for a terminal directive.\n * A terminal link function terminates the current\n * compilation recursion and handles compilation of the\n * subtree in the directive.\n *\n * @param {Element} el\n * @param {String} dirName\n * @param {String} value\n * @param {Object} options\n * @param {Object} [def]\n * @return {Function} terminalLinkFn\n */\n\nfunction makeTerminalNodeLinkFn(el, dirName, value, options, def) {\n  var parsed = parseDirective(value);\n  var descriptor = {\n    name: dirName,\n    expression: parsed.expression,\n    filters: parsed.filters,\n    raw: value,\n    // either an element directive, or if/for\n    // #2366 or custom terminal directive\n    def: def || resolveAsset(options, 'directives', dirName)\n  };\n  // check ref for v-for and router-view\n  if (dirName === 'for' || dirName === 'router-view') {\n    descriptor.ref = findRef(el);\n  }\n  var fn = function terminalNodeLinkFn(vm, el, host, scope, frag) {\n    if (descriptor.ref) {\n      defineReactive((scope || vm).$refs, descriptor.ref, null);\n    }\n    vm._bindDir(descriptor, el, host, scope, frag);\n  };\n  fn.terminal = true;\n  return fn;\n}\n\n/**\n * Compile the directives on an element and return a linker.\n *\n * @param {Array|NamedNodeMap} attrs\n * @param {Object} options\n * @return {Function}\n */\n\nfunction compileDirectives(attrs, options) {\n  var i = attrs.length;\n  var dirs = [];\n  var attr, name, value, rawName, rawValue, dirName, arg, modifiers, dirDef, tokens, matched;\n  while (i--) {\n    attr = attrs[i];\n    name = rawName = attr.name;\n    value = rawValue = attr.value;\n    tokens = parseText(value);\n    // reset arg\n    arg = null;\n    // check modifiers\n    modifiers = parseModifiers(name);\n    name = name.replace(modifierRE, '');\n\n    // attribute interpolations\n    if (tokens) {\n      value = tokensToExp(tokens);\n      arg = name;\n      pushDir('bind', directives.bind, tokens);\n      // warn against mixing mustaches with v-bind\n      if (process.env.NODE_ENV !== 'production') {\n        if (name === 'class' && Array.prototype.some.call(attrs, function (attr) {\n          return attr.name === ':class' || attr.name === 'v-bind:class';\n        })) {\n          warn('class=\"' + rawValue + '\": Do not mix mustache interpolation ' + 'and v-bind for \"class\" on the same element. Use one or the other.');\n        }\n      }\n    } else\n\n      // special attribute: transition\n      if (transitionRE.test(name)) {\n        modifiers.literal = !bindRE.test(name);\n        pushDir('transition', internalDirectives.transition);\n      } else\n\n        // event handlers\n        if (onRE.test(name)) {\n          arg = name.replace(onRE, '');\n          pushDir('on', directives.on);\n        } else\n\n          // attribute bindings\n          if (bindRE.test(name)) {\n            dirName = name.replace(bindRE, '');\n            if (dirName === 'style' || dirName === 'class') {\n              pushDir(dirName, internalDirectives[dirName]);\n            } else {\n              arg = dirName;\n              pushDir('bind', directives.bind);\n            }\n          } else\n\n            // normal directives\n            if (matched = name.match(dirAttrRE)) {\n              dirName = matched[1];\n              arg = matched[2];\n\n              // skip v-else (when used with v-show)\n              if (dirName === 'else') {\n                continue;\n              }\n\n              dirDef = resolveAsset(options, 'directives', dirName);\n\n              if (process.env.NODE_ENV !== 'production') {\n                assertAsset(dirDef, 'directive', dirName);\n              }\n\n              if (dirDef) {\n                pushDir(dirName, dirDef);\n              }\n            }\n  }\n\n  /**\n   * Push a directive.\n   *\n   * @param {String} dirName\n   * @param {Object|Function} def\n   * @param {Array} [interpTokens]\n   */\n\n  function pushDir(dirName, def, interpTokens) {\n    var hasOneTimeToken = interpTokens && hasOneTime(interpTokens);\n    var parsed = !hasOneTimeToken && parseDirective(value);\n    dirs.push({\n      name: dirName,\n      attr: rawName,\n      raw: rawValue,\n      def: def,\n      arg: arg,\n      modifiers: modifiers,\n      // conversion from interpolation strings with one-time token\n      // to expression is differed until directive bind time so that we\n      // have access to the actual vm context for one-time bindings.\n      expression: parsed && parsed.expression,\n      filters: parsed && parsed.filters,\n      interp: interpTokens,\n      hasOneTime: hasOneTimeToken\n    });\n  }\n\n  if (dirs.length) {\n    return makeNodeLinkFn(dirs);\n  }\n}\n\n/**\n * Parse modifiers from directive attribute name.\n *\n * @param {String} name\n * @return {Object}\n */\n\nfunction parseModifiers(name) {\n  var res = Object.create(null);\n  var match = name.match(modifierRE);\n  if (match) {\n    var i = match.length;\n    while (i--) {\n      res[match[i].slice(1)] = true;\n    }\n  }\n  return res;\n}\n\n/**\n * Build a link function for all directives on a single node.\n *\n * @param {Array} directives\n * @return {Function} directivesLinkFn\n */\n\nfunction makeNodeLinkFn(directives) {\n  return function nodeLinkFn(vm, el, host, scope, frag) {\n    // reverse apply because it's sorted low to high\n    var i = directives.length;\n    while (i--) {\n      vm._bindDir(directives[i], el, host, scope, frag);\n    }\n  };\n}\n\n/**\n * Check if an interpolation string contains one-time tokens.\n *\n * @param {Array} tokens\n * @return {Boolean}\n */\n\nfunction hasOneTime(tokens) {\n  var i = tokens.length;\n  while (i--) {\n    if (tokens[i].oneTime) return true;\n  }\n}\n\nvar specialCharRE = /[^\\w\\-:\\.]/;\n\n/**\n * Process an element or a DocumentFragment based on a\n * instance option object. This allows us to transclude\n * a template node/fragment before the instance is created,\n * so the processed fragment can then be cloned and reused\n * in v-for.\n *\n * @param {Element} el\n * @param {Object} options\n * @return {Element|DocumentFragment}\n */\n\nfunction transclude(el, options) {\n  // extract container attributes to pass them down\n  // to compiler, because they need to be compiled in\n  // parent scope. we are mutating the options object here\n  // assuming the same object will be used for compile\n  // right after this.\n  if (options) {\n    options._containerAttrs = extractAttrs(el);\n  }\n  // for template tags, what we want is its content as\n  // a documentFragment (for fragment instances)\n  if (isTemplate(el)) {\n    el = parseTemplate(el);\n  }\n  if (options) {\n    if (options._asComponent && !options.template) {\n      options.template = '<slot></slot>';\n    }\n    if (options.template) {\n      options._content = extractContent(el);\n      el = transcludeTemplate(el, options);\n    }\n  }\n  if (isFragment(el)) {\n    // anchors for fragment instance\n    // passing in `persist: true` to avoid them being\n    // discarded by IE during template cloning\n    prepend(createAnchor('v-start', true), el);\n    el.appendChild(createAnchor('v-end', true));\n  }\n  return el;\n}\n\n/**\n * Process the template option.\n * If the replace option is true this will swap the $el.\n *\n * @param {Element} el\n * @param {Object} options\n * @return {Element|DocumentFragment}\n */\n\nfunction transcludeTemplate(el, options) {\n  var template = options.template;\n  var frag = parseTemplate(template, true);\n  if (frag) {\n    var replacer = frag.firstChild;\n    var tag = replacer.tagName && replacer.tagName.toLowerCase();\n    if (options.replace) {\n      /* istanbul ignore if */\n      if (el === document.body) {\n        process.env.NODE_ENV !== 'production' && warn('You are mounting an instance with a template to ' + '<body>. This will replace <body> entirely. You ' + 'should probably use `replace: false` here.');\n      }\n      // there are many cases where the instance must\n      // become a fragment instance: basically anything that\n      // can create more than 1 root nodes.\n      if (\n      // multi-children template\n      frag.childNodes.length > 1 ||\n      // non-element template\n      replacer.nodeType !== 1 ||\n      // single nested component\n      tag === 'component' || resolveAsset(options, 'components', tag) || hasBindAttr(replacer, 'is') ||\n      // element directive\n      resolveAsset(options, 'elementDirectives', tag) ||\n      // for block\n      replacer.hasAttribute('v-for') ||\n      // if block\n      replacer.hasAttribute('v-if')) {\n        return frag;\n      } else {\n        options._replacerAttrs = extractAttrs(replacer);\n        mergeAttrs(el, replacer);\n        return replacer;\n      }\n    } else {\n      el.appendChild(frag);\n      return el;\n    }\n  } else {\n    process.env.NODE_ENV !== 'production' && warn('Invalid template option: ' + template);\n  }\n}\n\n/**\n * Helper to extract a component container's attributes\n * into a plain object array.\n *\n * @param {Element} el\n * @return {Array}\n */\n\nfunction extractAttrs(el) {\n  if (el.nodeType === 1 && el.hasAttributes()) {\n    return toArray(el.attributes);\n  }\n}\n\n/**\n * Merge the attributes of two elements, and make sure\n * the class names are merged properly.\n *\n * @param {Element} from\n * @param {Element} to\n */\n\nfunction mergeAttrs(from, to) {\n  var attrs = from.attributes;\n  var i = attrs.length;\n  var name, value;\n  while (i--) {\n    name = attrs[i].name;\n    value = attrs[i].value;\n    if (!to.hasAttribute(name) && !specialCharRE.test(name)) {\n      to.setAttribute(name, value);\n    } else if (name === 'class' && !parseText(value)) {\n      value.split(/\\s+/).forEach(function (cls) {\n        addClass(to, cls);\n      });\n    }\n  }\n}\n\n/**\n * Scan and determine slot content distribution.\n * We do this during transclusion instead at compile time so that\n * the distribution is decoupled from the compilation order of\n * the slots.\n *\n * @param {Element|DocumentFragment} template\n * @param {Element} content\n * @param {Vue} vm\n */\n\nfunction scanSlots(template, content, vm) {\n  if (!content) {\n    return;\n  }\n  var contents = vm._slotContents = {};\n  var slots = template.querySelectorAll('slot');\n  if (slots.length) {\n    var hasDefault, slot, name;\n    for (var i = 0, l = slots.length; i < l; i++) {\n      slot = slots[i];\n      /* eslint-disable no-cond-assign */\n      if (name = slot.getAttribute('name')) {\n        select(slot, name);\n      } else if (process.env.NODE_ENV !== 'production' && (name = getBindAttr(slot, 'name'))) {\n        warn('<slot :name=\"' + name + '\">: slot names cannot be dynamic.');\n      } else {\n        // default slot\n        hasDefault = true;\n      }\n      /* eslint-enable no-cond-assign */\n    }\n    if (hasDefault) {\n      contents['default'] = extractFragment(content.childNodes, content);\n    }\n  }\n\n  function select(slot, name) {\n    // named slot\n    var selector = '[slot=\"' + name + '\"]';\n    var nodes = content.querySelectorAll(selector);\n    if (nodes.length) {\n      contents[name] = extractFragment(nodes, content);\n    }\n  }\n}\n\n/**\n * Extract qualified content nodes from a node list.\n *\n * @param {NodeList} nodes\n * @param {Element} parent\n * @return {DocumentFragment}\n */\n\nfunction extractFragment(nodes, parent) {\n  var frag = document.createDocumentFragment();\n  nodes = toArray(nodes);\n  for (var i = 0, l = nodes.length; i < l; i++) {\n    var node = nodes[i];\n    if (node.parentNode === parent) {\n      if (isTemplate(node) && !node.hasAttribute('v-if') && !node.hasAttribute('v-for')) {\n        parent.removeChild(node);\n        node = parseTemplate(node);\n      }\n      frag.appendChild(node);\n    }\n  }\n  return frag;\n}\n\n\n\nvar compiler = Object.freeze({\n\tcompile: compile,\n\tcompileAndLinkProps: compileAndLinkProps,\n\tcompileRoot: compileRoot,\n\tterminalDirectives: terminalDirectives,\n\ttransclude: transclude,\n\tscanSlots: scanSlots\n});\n\nfunction stateMixin (Vue) {\n  /**\n   * Accessor for `$data` property, since setting $data\n   * requires observing the new object and updating\n   * proxied properties.\n   */\n\n  Object.defineProperty(Vue.prototype, '$data', {\n    get: function get() {\n      return this._data;\n    },\n    set: function set(newData) {\n      if (newData !== this._data) {\n        this._setData(newData);\n      }\n    }\n  });\n\n  /**\n   * Setup the scope of an instance, which contains:\n   * - observed data\n   * - computed properties\n   * - user methods\n   * - meta properties\n   */\n\n  Vue.prototype._initState = function () {\n    this._initProps();\n    this._initMeta();\n    this._initMethods();\n    this._initData();\n    this._initComputed();\n  };\n\n  /**\n   * Initialize props.\n   */\n\n  Vue.prototype._initProps = function () {\n    var options = this.$options;\n    var el = options.el;\n    var props = options.props;\n    if (props && !el) {\n      process.env.NODE_ENV !== 'production' && warn('Props will not be compiled if no `el` option is ' + 'provided at instantiation.');\n    }\n    // make sure to convert string selectors into element now\n    el = options.el = query(el);\n    this._propsUnlinkFn = el && el.nodeType === 1 && props\n    // props must be linked in proper scope if inside v-for\n    ? compileAndLinkProps(this, el, props, this._scope) : null;\n  };\n\n  /**\n   * Initialize the data.\n   */\n\n  Vue.prototype._initData = function () {\n    var propsData = this._data;\n    var optionsDataFn = this.$options.data;\n    var optionsData = optionsDataFn && optionsDataFn();\n    var runtimeData;\n    if (process.env.NODE_ENV !== 'production') {\n      runtimeData = (typeof this._runtimeData === 'function' ? this._runtimeData() : this._runtimeData) || {};\n      this._runtimeData = null;\n    }\n    if (optionsData) {\n      this._data = optionsData;\n      for (var prop in propsData) {\n        if (process.env.NODE_ENV !== 'production' && hasOwn(optionsData, prop) && !hasOwn(runtimeData, prop)) {\n          warn('Data field \"' + prop + '\" is already defined ' + 'as a prop. Use prop default value instead.');\n        }\n        if (this._props[prop].raw !== null || !hasOwn(optionsData, prop)) {\n          set(optionsData, prop, propsData[prop]);\n        }\n      }\n    }\n    var data = this._data;\n    // proxy data on instance\n    var keys = Object.keys(data);\n    var i, key;\n    i = keys.length;\n    while (i--) {\n      key = keys[i];\n      this._proxy(key);\n    }\n    // observe data\n    observe(data, this);\n  };\n\n  /**\n   * Swap the instance's $data. Called in $data's setter.\n   *\n   * @param {Object} newData\n   */\n\n  Vue.prototype._setData = function (newData) {\n    newData = newData || {};\n    var oldData = this._data;\n    this._data = newData;\n    var keys, key, i;\n    // unproxy keys not present in new data\n    keys = Object.keys(oldData);\n    i = keys.length;\n    while (i--) {\n      key = keys[i];\n      if (!(key in newData)) {\n        this._unproxy(key);\n      }\n    }\n    // proxy keys not already proxied,\n    // and trigger change for changed values\n    keys = Object.keys(newData);\n    i = keys.length;\n    while (i--) {\n      key = keys[i];\n      if (!hasOwn(this, key)) {\n        // new property\n        this._proxy(key);\n      }\n    }\n    oldData.__ob__.removeVm(this);\n    observe(newData, this);\n    this._digest();\n  };\n\n  /**\n   * Proxy a property, so that\n   * vm.prop === vm._data.prop\n   *\n   * @param {String} key\n   */\n\n  Vue.prototype._proxy = function (key) {\n    if (!isReserved(key)) {\n      // need to store ref to self here\n      // because these getter/setters might\n      // be called by child scopes via\n      // prototype inheritance.\n      var self = this;\n      Object.defineProperty(self, key, {\n        configurable: true,\n        enumerable: true,\n        get: function proxyGetter() {\n          return self._data[key];\n        },\n        set: function proxySetter(val) {\n          self._data[key] = val;\n        }\n      });\n    }\n  };\n\n  /**\n   * Unproxy a property.\n   *\n   * @param {String} key\n   */\n\n  Vue.prototype._unproxy = function (key) {\n    if (!isReserved(key)) {\n      delete this[key];\n    }\n  };\n\n  /**\n   * Force update on every watcher in scope.\n   */\n\n  Vue.prototype._digest = function () {\n    for (var i = 0, l = this._watchers.length; i < l; i++) {\n      this._watchers[i].update(true); // shallow updates\n    }\n  };\n\n  /**\n   * Setup computed properties. They are essentially\n   * special getter/setters\n   */\n\n  function noop() {}\n  Vue.prototype._initComputed = function () {\n    var computed = this.$options.computed;\n    if (computed) {\n      for (var key in computed) {\n        var userDef = computed[key];\n        var def = {\n          enumerable: true,\n          configurable: true\n        };\n        if (typeof userDef === 'function') {\n          def.get = makeComputedGetter(userDef, this);\n          def.set = noop;\n        } else {\n          def.get = userDef.get ? userDef.cache !== false ? makeComputedGetter(userDef.get, this) : bind(userDef.get, this) : noop;\n          def.set = userDef.set ? bind(userDef.set, this) : noop;\n        }\n        Object.defineProperty(this, key, def);\n      }\n    }\n  };\n\n  function makeComputedGetter(getter, owner) {\n    var watcher = new Watcher(owner, getter, null, {\n      lazy: true\n    });\n    return function computedGetter() {\n      if (watcher.dirty) {\n        watcher.evaluate();\n      }\n      if (Dep.target) {\n        watcher.depend();\n      }\n      return watcher.value;\n    };\n  }\n\n  /**\n   * Setup instance methods. Methods must be bound to the\n   * instance since they might be passed down as a prop to\n   * child components.\n   */\n\n  Vue.prototype._initMethods = function () {\n    var methods = this.$options.methods;\n    if (methods) {\n      for (var key in methods) {\n        this[key] = bind(methods[key], this);\n      }\n    }\n  };\n\n  /**\n   * Initialize meta information like $index, $key & $value.\n   */\n\n  Vue.prototype._initMeta = function () {\n    var metas = this.$options._meta;\n    if (metas) {\n      for (var key in metas) {\n        defineReactive(this, key, metas[key]);\n      }\n    }\n  };\n}\n\nvar eventRE = /^v-on:|^@/;\n\nfunction eventsMixin (Vue) {\n  /**\n   * Setup the instance's option events & watchers.\n   * If the value is a string, we pull it from the\n   * instance's methods by name.\n   */\n\n  Vue.prototype._initEvents = function () {\n    var options = this.$options;\n    if (options._asComponent) {\n      registerComponentEvents(this, options.el);\n    }\n    registerCallbacks(this, '$on', options.events);\n    registerCallbacks(this, '$watch', options.watch);\n  };\n\n  /**\n   * Register v-on events on a child component\n   *\n   * @param {Vue} vm\n   * @param {Element} el\n   */\n\n  function registerComponentEvents(vm, el) {\n    var attrs = el.attributes;\n    var name, handler;\n    for (var i = 0, l = attrs.length; i < l; i++) {\n      name = attrs[i].name;\n      if (eventRE.test(name)) {\n        name = name.replace(eventRE, '');\n        handler = (vm._scope || vm._context).$eval(attrs[i].value, true);\n        if (typeof handler === 'function') {\n          handler._fromParent = true;\n          vm.$on(name.replace(eventRE), handler);\n        } else if (process.env.NODE_ENV !== 'production') {\n          warn('v-on:' + name + '=\"' + attrs[i].value + '\"' + (vm.$options.name ? ' on component <' + vm.$options.name + '>' : '') + ' expects a function value, got ' + handler);\n        }\n      }\n    }\n  }\n\n  /**\n   * Register callbacks for option events and watchers.\n   *\n   * @param {Vue} vm\n   * @param {String} action\n   * @param {Object} hash\n   */\n\n  function registerCallbacks(vm, action, hash) {\n    if (!hash) return;\n    var handlers, key, i, j;\n    for (key in hash) {\n      handlers = hash[key];\n      if (isArray(handlers)) {\n        for (i = 0, j = handlers.length; i < j; i++) {\n          register(vm, action, key, handlers[i]);\n        }\n      } else {\n        register(vm, action, key, handlers);\n      }\n    }\n  }\n\n  /**\n   * Helper to register an event/watch callback.\n   *\n   * @param {Vue} vm\n   * @param {String} action\n   * @param {String} key\n   * @param {Function|String|Object} handler\n   * @param {Object} [options]\n   */\n\n  function register(vm, action, key, handler, options) {\n    var type = typeof handler;\n    if (type === 'function') {\n      vm[action](key, handler, options);\n    } else if (type === 'string') {\n      var methods = vm.$options.methods;\n      var method = methods && methods[handler];\n      if (method) {\n        vm[action](key, method, options);\n      } else {\n        process.env.NODE_ENV !== 'production' && warn('Unknown method: \"' + handler + '\" when ' + 'registering callback for ' + action + ': \"' + key + '\".');\n      }\n    } else if (handler && type === 'object') {\n      register(vm, action, key, handler.handler, handler);\n    }\n  }\n\n  /**\n   * Setup recursive attached/detached calls\n   */\n\n  Vue.prototype._initDOMHooks = function () {\n    this.$on('hook:attached', onAttached);\n    this.$on('hook:detached', onDetached);\n  };\n\n  /**\n   * Callback to recursively call attached hook on children\n   */\n\n  function onAttached() {\n    if (!this._isAttached) {\n      this._isAttached = true;\n      this.$children.forEach(callAttach);\n    }\n  }\n\n  /**\n   * Iterator to call attached hook\n   *\n   * @param {Vue} child\n   */\n\n  function callAttach(child) {\n    if (!child._isAttached && inDoc(child.$el)) {\n      child._callHook('attached');\n    }\n  }\n\n  /**\n   * Callback to recursively call detached hook on children\n   */\n\n  function onDetached() {\n    if (this._isAttached) {\n      this._isAttached = false;\n      this.$children.forEach(callDetach);\n    }\n  }\n\n  /**\n   * Iterator to call detached hook\n   *\n   * @param {Vue} child\n   */\n\n  function callDetach(child) {\n    if (child._isAttached && !inDoc(child.$el)) {\n      child._callHook('detached');\n    }\n  }\n\n  /**\n   * Trigger all handlers for a hook\n   *\n   * @param {String} hook\n   */\n\n  Vue.prototype._callHook = function (hook) {\n    this.$emit('pre-hook:' + hook);\n    var handlers = this.$options[hook];\n    if (handlers) {\n      for (var i = 0, j = handlers.length; i < j; i++) {\n        handlers[i].call(this);\n      }\n    }\n    this.$emit('hook:' + hook);\n  };\n}\n\nfunction noop() {}\n\n/**\n * A directive links a DOM element with a piece of data,\n * which is the result of evaluating an expression.\n * It registers a watcher with the expression and calls\n * the DOM update function when a change is triggered.\n *\n * @param {String} name\n * @param {Node} el\n * @param {Vue} vm\n * @param {Object} descriptor\n *                 - {String} name\n *                 - {Object} def\n *                 - {String} expression\n *                 - {Array<Object>} [filters]\n *                 - {Boolean} literal\n *                 - {String} attr\n *                 - {String} raw\n * @param {Object} def - directive definition object\n * @param {Vue} [host] - transclusion host component\n * @param {Object} [scope] - v-for scope\n * @param {Fragment} [frag] - owner fragment\n * @constructor\n */\nfunction Directive(descriptor, vm, el, host, scope, frag) {\n  this.vm = vm;\n  this.el = el;\n  // copy descriptor properties\n  this.descriptor = descriptor;\n  this.name = descriptor.name;\n  this.expression = descriptor.expression;\n  this.arg = descriptor.arg;\n  this.modifiers = descriptor.modifiers;\n  this.filters = descriptor.filters;\n  this.literal = this.modifiers && this.modifiers.literal;\n  // private\n  this._locked = false;\n  this._bound = false;\n  this._listeners = null;\n  // link context\n  this._host = host;\n  this._scope = scope;\n  this._frag = frag;\n  // store directives on node in dev mode\n  if (process.env.NODE_ENV !== 'production' && this.el) {\n    this.el._vue_directives = this.el._vue_directives || [];\n    this.el._vue_directives.push(this);\n  }\n}\n\n/**\n * Initialize the directive, mixin definition properties,\n * setup the watcher, call definition bind() and update()\n * if present.\n *\n * @param {Object} def\n */\n\nDirective.prototype._bind = function () {\n  var name = this.name;\n  var descriptor = this.descriptor;\n\n  // remove attribute\n  if ((name !== 'cloak' || this.vm._isCompiled) && this.el && this.el.removeAttribute) {\n    var attr = descriptor.attr || 'v-' + name;\n    this.el.removeAttribute(attr);\n  }\n\n  // copy def properties\n  var def = descriptor.def;\n  if (typeof def === 'function') {\n    this.update = def;\n  } else {\n    extend(this, def);\n  }\n\n  // setup directive params\n  this._setupParams();\n\n  // initial bind\n  if (this.bind) {\n    this.bind();\n  }\n  this._bound = true;\n\n  if (this.literal) {\n    this.update && this.update(descriptor.raw);\n  } else if ((this.expression || this.modifiers) && (this.update || this.twoWay) && !this._checkStatement()) {\n    // wrapped updater for context\n    var dir = this;\n    if (this.update) {\n      this._update = function (val, oldVal) {\n        if (!dir._locked) {\n          dir.update(val, oldVal);\n        }\n      };\n    } else {\n      this._update = noop;\n    }\n    var preProcess = this._preProcess ? bind(this._preProcess, this) : null;\n    var postProcess = this._postProcess ? bind(this._postProcess, this) : null;\n    var watcher = this._watcher = new Watcher(this.vm, this.expression, this._update, // callback\n    {\n      filters: this.filters,\n      twoWay: this.twoWay,\n      deep: this.deep,\n      preProcess: preProcess,\n      postProcess: postProcess,\n      scope: this._scope\n    });\n    // v-model with inital inline value need to sync back to\n    // model instead of update to DOM on init. They would\n    // set the afterBind hook to indicate that.\n    if (this.afterBind) {\n      this.afterBind();\n    } else if (this.update) {\n      this.update(watcher.value);\n    }\n  }\n};\n\n/**\n * Setup all param attributes, e.g. track-by,\n * transition-mode, etc...\n */\n\nDirective.prototype._setupParams = function () {\n  if (!this.params) {\n    return;\n  }\n  var params = this.params;\n  // swap the params array with a fresh object.\n  this.params = Object.create(null);\n  var i = params.length;\n  var key, val, mappedKey;\n  while (i--) {\n    key = params[i];\n    mappedKey = camelize(key);\n    val = getBindAttr(this.el, key);\n    if (val != null) {\n      // dynamic\n      this._setupParamWatcher(mappedKey, val);\n    } else {\n      // static\n      val = getAttr(this.el, key);\n      if (val != null) {\n        this.params[mappedKey] = val === '' ? true : val;\n      }\n    }\n  }\n};\n\n/**\n * Setup a watcher for a dynamic param.\n *\n * @param {String} key\n * @param {String} expression\n */\n\nDirective.prototype._setupParamWatcher = function (key, expression) {\n  var self = this;\n  var called = false;\n  var unwatch = (this._scope || this.vm).$watch(expression, function (val, oldVal) {\n    self.params[key] = val;\n    // since we are in immediate mode,\n    // only call the param change callbacks if this is not the first update.\n    if (called) {\n      var cb = self.paramWatchers && self.paramWatchers[key];\n      if (cb) {\n        cb.call(self, val, oldVal);\n      }\n    } else {\n      called = true;\n    }\n  }, {\n    immediate: true,\n    user: false\n  });(this._paramUnwatchFns || (this._paramUnwatchFns = [])).push(unwatch);\n};\n\n/**\n * Check if the directive is a function caller\n * and if the expression is a callable one. If both true,\n * we wrap up the expression and use it as the event\n * handler.\n *\n * e.g. on-click=\"a++\"\n *\n * @return {Boolean}\n */\n\nDirective.prototype._checkStatement = function () {\n  var expression = this.expression;\n  if (expression && this.acceptStatement && !isSimplePath(expression)) {\n    var fn = parseExpression(expression).get;\n    var scope = this._scope || this.vm;\n    var handler = function handler(e) {\n      scope.$event = e;\n      fn.call(scope, scope);\n      scope.$event = null;\n    };\n    if (this.filters) {\n      handler = scope._applyFilters(handler, null, this.filters);\n    }\n    this.update(handler);\n    return true;\n  }\n};\n\n/**\n * Set the corresponding value with the setter.\n * This should only be used in two-way directives\n * e.g. v-model.\n *\n * @param {*} value\n * @public\n */\n\nDirective.prototype.set = function (value) {\n  /* istanbul ignore else */\n  if (this.twoWay) {\n    this._withLock(function () {\n      this._watcher.set(value);\n    });\n  } else if (process.env.NODE_ENV !== 'production') {\n    warn('Directive.set() can only be used inside twoWay' + 'directives.');\n  }\n};\n\n/**\n * Execute a function while preventing that function from\n * triggering updates on this directive instance.\n *\n * @param {Function} fn\n */\n\nDirective.prototype._withLock = function (fn) {\n  var self = this;\n  self._locked = true;\n  fn.call(self);\n  nextTick(function () {\n    self._locked = false;\n  });\n};\n\n/**\n * Convenience method that attaches a DOM event listener\n * to the directive element and autometically tears it down\n * during unbind.\n *\n * @param {String} event\n * @param {Function} handler\n * @param {Boolean} [useCapture]\n */\n\nDirective.prototype.on = function (event, handler, useCapture) {\n  on(this.el, event, handler, useCapture);(this._listeners || (this._listeners = [])).push([event, handler]);\n};\n\n/**\n * Teardown the watcher and call unbind.\n */\n\nDirective.prototype._teardown = function () {\n  if (this._bound) {\n    this._bound = false;\n    if (this.unbind) {\n      this.unbind();\n    }\n    if (this._watcher) {\n      this._watcher.teardown();\n    }\n    var listeners = this._listeners;\n    var i;\n    if (listeners) {\n      i = listeners.length;\n      while (i--) {\n        off(this.el, listeners[i][0], listeners[i][1]);\n      }\n    }\n    var unwatchFns = this._paramUnwatchFns;\n    if (unwatchFns) {\n      i = unwatchFns.length;\n      while (i--) {\n        unwatchFns[i]();\n      }\n    }\n    if (process.env.NODE_ENV !== 'production' && this.el) {\n      this.el._vue_directives.$remove(this);\n    }\n    this.vm = this.el = this._watcher = this._listeners = null;\n  }\n};\n\nfunction lifecycleMixin (Vue) {\n  /**\n   * Update v-ref for component.\n   *\n   * @param {Boolean} remove\n   */\n\n  Vue.prototype._updateRef = function (remove) {\n    var ref = this.$options._ref;\n    if (ref) {\n      var refs = (this._scope || this._context).$refs;\n      if (remove) {\n        if (refs[ref] === this) {\n          refs[ref] = null;\n        }\n      } else {\n        refs[ref] = this;\n      }\n    }\n  };\n\n  /**\n   * Transclude, compile and link element.\n   *\n   * If a pre-compiled linker is available, that means the\n   * passed in element will be pre-transcluded and compiled\n   * as well - all we need to do is to call the linker.\n   *\n   * Otherwise we need to call transclude/compile/link here.\n   *\n   * @param {Element} el\n   */\n\n  Vue.prototype._compile = function (el) {\n    var options = this.$options;\n\n    // transclude and init element\n    // transclude can potentially replace original\n    // so we need to keep reference; this step also injects\n    // the template and caches the original attributes\n    // on the container node and replacer node.\n    var original = el;\n    el = transclude(el, options);\n    this._initElement(el);\n\n    // handle v-pre on root node (#2026)\n    if (el.nodeType === 1 && getAttr(el, 'v-pre') !== null) {\n      return;\n    }\n\n    // root is always compiled per-instance, because\n    // container attrs and props can be different every time.\n    var contextOptions = this._context && this._context.$options;\n    var rootLinker = compileRoot(el, options, contextOptions);\n\n    // scan for slot distribution before compiling the content\n    // so that it's decoupeld from slot/directive compilation order\n    scanSlots(el, options._content, this);\n\n    // compile and link the rest\n    var contentLinkFn;\n    var ctor = this.constructor;\n    // component compilation can be cached\n    // as long as it's not using inline-template\n    if (options._linkerCachable) {\n      contentLinkFn = ctor.linker;\n      if (!contentLinkFn) {\n        contentLinkFn = ctor.linker = compile(el, options);\n      }\n    }\n\n    // link phase\n    // make sure to link root with prop scope!\n    var rootUnlinkFn = rootLinker(this, el, this._scope);\n    var contentUnlinkFn = contentLinkFn ? contentLinkFn(this, el) : compile(el, options)(this, el);\n\n    // register composite unlink function\n    // to be called during instance destruction\n    this._unlinkFn = function () {\n      rootUnlinkFn();\n      // passing destroying: true to avoid searching and\n      // splicing the directives\n      contentUnlinkFn(true);\n    };\n\n    // finally replace original\n    if (options.replace) {\n      replace(original, el);\n    }\n\n    this._isCompiled = true;\n    this._callHook('compiled');\n  };\n\n  /**\n   * Initialize instance element. Called in the public\n   * $mount() method.\n   *\n   * @param {Element} el\n   */\n\n  Vue.prototype._initElement = function (el) {\n    if (isFragment(el)) {\n      this._isFragment = true;\n      this.$el = this._fragmentStart = el.firstChild;\n      this._fragmentEnd = el.lastChild;\n      // set persisted text anchors to empty\n      if (this._fragmentStart.nodeType === 3) {\n        this._fragmentStart.data = this._fragmentEnd.data = '';\n      }\n      this._fragment = el;\n    } else {\n      this.$el = el;\n    }\n    this.$el.__vue__ = this;\n    this._callHook('beforeCompile');\n  };\n\n  /**\n   * Create and bind a directive to an element.\n   *\n   * @param {String} name - directive name\n   * @param {Node} node   - target node\n   * @param {Object} desc - parsed directive descriptor\n   * @param {Object} def  - directive definition object\n   * @param {Vue} [host] - transclusion host component\n   * @param {Object} [scope] - v-for scope\n   * @param {Fragment} [frag] - owner fragment\n   */\n\n  Vue.prototype._bindDir = function (descriptor, node, host, scope, frag) {\n    this._directives.push(new Directive(descriptor, this, node, host, scope, frag));\n  };\n\n  /**\n   * Teardown an instance, unobserves the data, unbind all the\n   * directives, turn off all the event listeners, etc.\n   *\n   * @param {Boolean} remove - whether to remove the DOM node.\n   * @param {Boolean} deferCleanup - if true, defer cleanup to\n   *                                 be called later\n   */\n\n  Vue.prototype._destroy = function (remove, deferCleanup) {\n    if (this._isBeingDestroyed) {\n      if (!deferCleanup) {\n        this._cleanup();\n      }\n      return;\n    }\n\n    var destroyReady;\n    var pendingRemoval;\n\n    var self = this;\n    // Cleanup should be called either synchronously or asynchronoysly as\n    // callback of this.$remove(), or if remove and deferCleanup are false.\n    // In any case it should be called after all other removing, unbinding and\n    // turning of is done\n    var cleanupIfPossible = function cleanupIfPossible() {\n      if (destroyReady && !pendingRemoval && !deferCleanup) {\n        self._cleanup();\n      }\n    };\n\n    // remove DOM element\n    if (remove && this.$el) {\n      pendingRemoval = true;\n      this.$remove(function () {\n        pendingRemoval = false;\n        cleanupIfPossible();\n      });\n    }\n\n    this._callHook('beforeDestroy');\n    this._isBeingDestroyed = true;\n    var i;\n    // remove self from parent. only necessary\n    // if parent is not being destroyed as well.\n    var parent = this.$parent;\n    if (parent && !parent._isBeingDestroyed) {\n      parent.$children.$remove(this);\n      // unregister ref (remove: true)\n      this._updateRef(true);\n    }\n    // destroy all children.\n    i = this.$children.length;\n    while (i--) {\n      this.$children[i].$destroy();\n    }\n    // teardown props\n    if (this._propsUnlinkFn) {\n      this._propsUnlinkFn();\n    }\n    // teardown all directives. this also tearsdown all\n    // directive-owned watchers.\n    if (this._unlinkFn) {\n      this._unlinkFn();\n    }\n    i = this._watchers.length;\n    while (i--) {\n      this._watchers[i].teardown();\n    }\n    // remove reference to self on $el\n    if (this.$el) {\n      this.$el.__vue__ = null;\n    }\n\n    destroyReady = true;\n    cleanupIfPossible();\n  };\n\n  /**\n   * Clean up to ensure garbage collection.\n   * This is called after the leave transition if there\n   * is any.\n   */\n\n  Vue.prototype._cleanup = function () {\n    if (this._isDestroyed) {\n      return;\n    }\n    // remove self from owner fragment\n    // do it in cleanup so that we can call $destroy with\n    // defer right when a fragment is about to be removed.\n    if (this._frag) {\n      this._frag.children.$remove(this);\n    }\n    // remove reference from data ob\n    // frozen object may not have observer.\n    if (this._data.__ob__) {\n      this._data.__ob__.removeVm(this);\n    }\n    // Clean up references to private properties and other\n    // instances. preserve reference to _data so that proxy\n    // accessors still work. The only potential side effect\n    // here is that mutating the instance after it's destroyed\n    // may affect the state of other components that are still\n    // observing the same object, but that seems to be a\n    // reasonable responsibility for the user rather than\n    // always throwing an error on them.\n    this.$el = this.$parent = this.$root = this.$children = this._watchers = this._context = this._scope = this._directives = null;\n    // call the last hook...\n    this._isDestroyed = true;\n    this._callHook('destroyed');\n    // turn off all instance listeners.\n    this.$off();\n  };\n}\n\nfunction miscMixin (Vue) {\n  /**\n   * Apply a list of filter (descriptors) to a value.\n   * Using plain for loops here because this will be called in\n   * the getter of any watcher with filters so it is very\n   * performance sensitive.\n   *\n   * @param {*} value\n   * @param {*} [oldValue]\n   * @param {Array} filters\n   * @param {Boolean} write\n   * @return {*}\n   */\n\n  Vue.prototype._applyFilters = function (value, oldValue, filters, write) {\n    var filter, fn, args, arg, offset, i, l, j, k;\n    for (i = 0, l = filters.length; i < l; i++) {\n      filter = filters[i];\n      fn = resolveAsset(this.$options, 'filters', filter.name);\n      if (process.env.NODE_ENV !== 'production') {\n        assertAsset(fn, 'filter', filter.name);\n      }\n      if (!fn) continue;\n      fn = write ? fn.write : fn.read || fn;\n      if (typeof fn !== 'function') continue;\n      args = write ? [value, oldValue] : [value];\n      offset = write ? 2 : 1;\n      if (filter.args) {\n        for (j = 0, k = filter.args.length; j < k; j++) {\n          arg = filter.args[j];\n          args[j + offset] = arg.dynamic ? this.$get(arg.value) : arg.value;\n        }\n      }\n      value = fn.apply(this, args);\n    }\n    return value;\n  };\n\n  /**\n   * Resolve a component, depending on whether the component\n   * is defined normally or using an async factory function.\n   * Resolves synchronously if already resolved, otherwise\n   * resolves asynchronously and caches the resolved\n   * constructor on the factory.\n   *\n   * @param {String} id\n   * @param {Function} cb\n   */\n\n  Vue.prototype._resolveComponent = function (id, cb) {\n    var factory = resolveAsset(this.$options, 'components', id);\n    if (process.env.NODE_ENV !== 'production') {\n      assertAsset(factory, 'component', id);\n    }\n    if (!factory) {\n      return;\n    }\n    // async component factory\n    if (!factory.options) {\n      if (factory.resolved) {\n        // cached\n        cb(factory.resolved);\n      } else if (factory.requested) {\n        // pool callbacks\n        factory.pendingCallbacks.push(cb);\n      } else {\n        factory.requested = true;\n        var cbs = factory.pendingCallbacks = [cb];\n        factory.call(this, function resolve(res) {\n          if (isPlainObject(res)) {\n            res = Vue.extend(res);\n          }\n          // cache resolved\n          factory.resolved = res;\n          // invoke callbacks\n          for (var i = 0, l = cbs.length; i < l; i++) {\n            cbs[i](res);\n          }\n        }, function reject(reason) {\n          process.env.NODE_ENV !== 'production' && warn('Failed to resolve async component: ' + id + '. ' + (reason ? '\\nReason: ' + reason : ''));\n        });\n      }\n    } else {\n      // normal component\n      cb(factory);\n    }\n  };\n}\n\nvar filterRE$1 = /[^|]\\|[^|]/;\n\nfunction dataAPI (Vue) {\n  /**\n   * Get the value from an expression on this vm.\n   *\n   * @param {String} exp\n   * @param {Boolean} [asStatement]\n   * @return {*}\n   */\n\n  Vue.prototype.$get = function (exp, asStatement) {\n    var res = parseExpression(exp);\n    if (res) {\n      if (asStatement && !isSimplePath(exp)) {\n        var self = this;\n        return function statementHandler() {\n          self.$arguments = toArray(arguments);\n          var result = res.get.call(self, self);\n          self.$arguments = null;\n          return result;\n        };\n      } else {\n        try {\n          return res.get.call(this, this);\n        } catch (e) {}\n      }\n    }\n  };\n\n  /**\n   * Set the value from an expression on this vm.\n   * The expression must be a valid left-hand\n   * expression in an assignment.\n   *\n   * @param {String} exp\n   * @param {*} val\n   */\n\n  Vue.prototype.$set = function (exp, val) {\n    var res = parseExpression(exp, true);\n    if (res && res.set) {\n      res.set.call(this, this, val);\n    }\n  };\n\n  /**\n   * Delete a property on the VM\n   *\n   * @param {String} key\n   */\n\n  Vue.prototype.$delete = function (key) {\n    del(this._data, key);\n  };\n\n  /**\n   * Watch an expression, trigger callback when its\n   * value changes.\n   *\n   * @param {String|Function} expOrFn\n   * @param {Function} cb\n   * @param {Object} [options]\n   *                 - {Boolean} deep\n   *                 - {Boolean} immediate\n   * @return {Function} - unwatchFn\n   */\n\n  Vue.prototype.$watch = function (expOrFn, cb, options) {\n    var vm = this;\n    var parsed;\n    if (typeof expOrFn === 'string') {\n      parsed = parseDirective(expOrFn);\n      expOrFn = parsed.expression;\n    }\n    var watcher = new Watcher(vm, expOrFn, cb, {\n      deep: options && options.deep,\n      sync: options && options.sync,\n      filters: parsed && parsed.filters,\n      user: !options || options.user !== false\n    });\n    if (options && options.immediate) {\n      cb.call(vm, watcher.value);\n    }\n    return function unwatchFn() {\n      watcher.teardown();\n    };\n  };\n\n  /**\n   * Evaluate a text directive, including filters.\n   *\n   * @param {String} text\n   * @param {Boolean} [asStatement]\n   * @return {String}\n   */\n\n  Vue.prototype.$eval = function (text, asStatement) {\n    // check for filters.\n    if (filterRE$1.test(text)) {\n      var dir = parseDirective(text);\n      // the filter regex check might give false positive\n      // for pipes inside strings, so it's possible that\n      // we don't get any filters here\n      var val = this.$get(dir.expression, asStatement);\n      return dir.filters ? this._applyFilters(val, null, dir.filters) : val;\n    } else {\n      // no filter\n      return this.$get(text, asStatement);\n    }\n  };\n\n  /**\n   * Interpolate a piece of template text.\n   *\n   * @param {String} text\n   * @return {String}\n   */\n\n  Vue.prototype.$interpolate = function (text) {\n    var tokens = parseText(text);\n    var vm = this;\n    if (tokens) {\n      if (tokens.length === 1) {\n        return vm.$eval(tokens[0].value) + '';\n      } else {\n        return tokens.map(function (token) {\n          return token.tag ? vm.$eval(token.value) : token.value;\n        }).join('');\n      }\n    } else {\n      return text;\n    }\n  };\n\n  /**\n   * Log instance data as a plain JS object\n   * so that it is easier to inspect in console.\n   * This method assumes console is available.\n   *\n   * @param {String} [path]\n   */\n\n  Vue.prototype.$log = function (path) {\n    var data = path ? getPath(this._data, path) : this._data;\n    if (data) {\n      data = clean(data);\n    }\n    // include computed fields\n    if (!path) {\n      for (var key in this.$options.computed) {\n        data[key] = clean(this[key]);\n      }\n    }\n    console.log(data);\n  };\n\n  /**\n   * \"clean\" a getter/setter converted object into a plain\n   * object copy.\n   *\n   * @param {Object} - obj\n   * @return {Object}\n   */\n\n  function clean(obj) {\n    return JSON.parse(JSON.stringify(obj));\n  }\n}\n\nfunction domAPI (Vue) {\n  /**\n   * Convenience on-instance nextTick. The callback is\n   * auto-bound to the instance, and this avoids component\n   * modules having to rely on the global Vue.\n   *\n   * @param {Function} fn\n   */\n\n  Vue.prototype.$nextTick = function (fn) {\n    nextTick(fn, this);\n  };\n\n  /**\n   * Append instance to target\n   *\n   * @param {Node} target\n   * @param {Function} [cb]\n   * @param {Boolean} [withTransition] - defaults to true\n   */\n\n  Vue.prototype.$appendTo = function (target, cb, withTransition) {\n    return insert(this, target, cb, withTransition, append, appendWithTransition);\n  };\n\n  /**\n   * Prepend instance to target\n   *\n   * @param {Node} target\n   * @param {Function} [cb]\n   * @param {Boolean} [withTransition] - defaults to true\n   */\n\n  Vue.prototype.$prependTo = function (target, cb, withTransition) {\n    target = query(target);\n    if (target.hasChildNodes()) {\n      this.$before(target.firstChild, cb, withTransition);\n    } else {\n      this.$appendTo(target, cb, withTransition);\n    }\n    return this;\n  };\n\n  /**\n   * Insert instance before target\n   *\n   * @param {Node} target\n   * @param {Function} [cb]\n   * @param {Boolean} [withTransition] - defaults to true\n   */\n\n  Vue.prototype.$before = function (target, cb, withTransition) {\n    return insert(this, target, cb, withTransition, beforeWithCb, beforeWithTransition);\n  };\n\n  /**\n   * Insert instance after target\n   *\n   * @param {Node} target\n   * @param {Function} [cb]\n   * @param {Boolean} [withTransition] - defaults to true\n   */\n\n  Vue.prototype.$after = function (target, cb, withTransition) {\n    target = query(target);\n    if (target.nextSibling) {\n      this.$before(target.nextSibling, cb, withTransition);\n    } else {\n      this.$appendTo(target.parentNode, cb, withTransition);\n    }\n    return this;\n  };\n\n  /**\n   * Remove instance from DOM\n   *\n   * @param {Function} [cb]\n   * @param {Boolean} [withTransition] - defaults to true\n   */\n\n  Vue.prototype.$remove = function (cb, withTransition) {\n    if (!this.$el.parentNode) {\n      return cb && cb();\n    }\n    var inDocument = this._isAttached && inDoc(this.$el);\n    // if we are not in document, no need to check\n    // for transitions\n    if (!inDocument) withTransition = false;\n    var self = this;\n    var realCb = function realCb() {\n      if (inDocument) self._callHook('detached');\n      if (cb) cb();\n    };\n    if (this._isFragment) {\n      removeNodeRange(this._fragmentStart, this._fragmentEnd, this, this._fragment, realCb);\n    } else {\n      var op = withTransition === false ? removeWithCb : removeWithTransition;\n      op(this.$el, this, realCb);\n    }\n    return this;\n  };\n\n  /**\n   * Shared DOM insertion function.\n   *\n   * @param {Vue} vm\n   * @param {Element} target\n   * @param {Function} [cb]\n   * @param {Boolean} [withTransition]\n   * @param {Function} op1 - op for non-transition insert\n   * @param {Function} op2 - op for transition insert\n   * @return vm\n   */\n\n  function insert(vm, target, cb, withTransition, op1, op2) {\n    target = query(target);\n    var targetIsDetached = !inDoc(target);\n    var op = withTransition === false || targetIsDetached ? op1 : op2;\n    var shouldCallHook = !targetIsDetached && !vm._isAttached && !inDoc(vm.$el);\n    if (vm._isFragment) {\n      mapNodeRange(vm._fragmentStart, vm._fragmentEnd, function (node) {\n        op(node, target, vm);\n      });\n      cb && cb();\n    } else {\n      op(vm.$el, target, vm, cb);\n    }\n    if (shouldCallHook) {\n      vm._callHook('attached');\n    }\n    return vm;\n  }\n\n  /**\n   * Check for selectors\n   *\n   * @param {String|Element} el\n   */\n\n  function query(el) {\n    return typeof el === 'string' ? document.querySelector(el) : el;\n  }\n\n  /**\n   * Append operation that takes a callback.\n   *\n   * @param {Node} el\n   * @param {Node} target\n   * @param {Vue} vm - unused\n   * @param {Function} [cb]\n   */\n\n  function append(el, target, vm, cb) {\n    target.appendChild(el);\n    if (cb) cb();\n  }\n\n  /**\n   * InsertBefore operation that takes a callback.\n   *\n   * @param {Node} el\n   * @param {Node} target\n   * @param {Vue} vm - unused\n   * @param {Function} [cb]\n   */\n\n  function beforeWithCb(el, target, vm, cb) {\n    before(el, target);\n    if (cb) cb();\n  }\n\n  /**\n   * Remove operation that takes a callback.\n   *\n   * @param {Node} el\n   * @param {Vue} vm - unused\n   * @param {Function} [cb]\n   */\n\n  function removeWithCb(el, vm, cb) {\n    remove(el);\n    if (cb) cb();\n  }\n}\n\nfunction eventsAPI (Vue) {\n  /**\n   * Listen on the given `event` with `fn`.\n   *\n   * @param {String} event\n   * @param {Function} fn\n   */\n\n  Vue.prototype.$on = function (event, fn) {\n    (this._events[event] || (this._events[event] = [])).push(fn);\n    modifyListenerCount(this, event, 1);\n    return this;\n  };\n\n  /**\n   * Adds an `event` listener that will be invoked a single\n   * time then automatically removed.\n   *\n   * @param {String} event\n   * @param {Function} fn\n   */\n\n  Vue.prototype.$once = function (event, fn) {\n    var self = this;\n    function on() {\n      self.$off(event, on);\n      fn.apply(this, arguments);\n    }\n    on.fn = fn;\n    this.$on(event, on);\n    return this;\n  };\n\n  /**\n   * Remove the given callback for `event` or all\n   * registered callbacks.\n   *\n   * @param {String} event\n   * @param {Function} fn\n   */\n\n  Vue.prototype.$off = function (event, fn) {\n    var cbs;\n    // all\n    if (!arguments.length) {\n      if (this.$parent) {\n        for (event in this._events) {\n          cbs = this._events[event];\n          if (cbs) {\n            modifyListenerCount(this, event, -cbs.length);\n          }\n        }\n      }\n      this._events = {};\n      return this;\n    }\n    // specific event\n    cbs = this._events[event];\n    if (!cbs) {\n      return this;\n    }\n    if (arguments.length === 1) {\n      modifyListenerCount(this, event, -cbs.length);\n      this._events[event] = null;\n      return this;\n    }\n    // specific handler\n    var cb;\n    var i = cbs.length;\n    while (i--) {\n      cb = cbs[i];\n      if (cb === fn || cb.fn === fn) {\n        modifyListenerCount(this, event, -1);\n        cbs.splice(i, 1);\n        break;\n      }\n    }\n    return this;\n  };\n\n  /**\n   * Trigger an event on self.\n   *\n   * @param {String|Object} event\n   * @return {Boolean} shouldPropagate\n   */\n\n  Vue.prototype.$emit = function (event) {\n    var isSource = typeof event === 'string';\n    event = isSource ? event : event.name;\n    var cbs = this._events[event];\n    var shouldPropagate = isSource || !cbs;\n    if (cbs) {\n      cbs = cbs.length > 1 ? toArray(cbs) : cbs;\n      // this is a somewhat hacky solution to the question raised\n      // in #2102: for an inline component listener like <comp @test=\"doThis\">,\n      // the propagation handling is somewhat broken. Therefore we\n      // need to treat these inline callbacks differently.\n      var hasParentCbs = isSource && cbs.some(function (cb) {\n        return cb._fromParent;\n      });\n      if (hasParentCbs) {\n        shouldPropagate = false;\n      }\n      var args = toArray(arguments, 1);\n      for (var i = 0, l = cbs.length; i < l; i++) {\n        var cb = cbs[i];\n        var res = cb.apply(this, args);\n        if (res === true && (!hasParentCbs || cb._fromParent)) {\n          shouldPropagate = true;\n        }\n      }\n    }\n    return shouldPropagate;\n  };\n\n  /**\n   * Recursively broadcast an event to all children instances.\n   *\n   * @param {String|Object} event\n   * @param {...*} additional arguments\n   */\n\n  Vue.prototype.$broadcast = function (event) {\n    var isSource = typeof event === 'string';\n    event = isSource ? event : event.name;\n    // if no child has registered for this event,\n    // then there's no need to broadcast.\n    if (!this._eventsCount[event]) return;\n    var children = this.$children;\n    var args = toArray(arguments);\n    if (isSource) {\n      // use object event to indicate non-source emit\n      // on children\n      args[0] = { name: event, source: this };\n    }\n    for (var i = 0, l = children.length; i < l; i++) {\n      var child = children[i];\n      var shouldPropagate = child.$emit.apply(child, args);\n      if (shouldPropagate) {\n        child.$broadcast.apply(child, args);\n      }\n    }\n    return this;\n  };\n\n  /**\n   * Recursively propagate an event up the parent chain.\n   *\n   * @param {String} event\n   * @param {...*} additional arguments\n   */\n\n  Vue.prototype.$dispatch = function (event) {\n    var shouldPropagate = this.$emit.apply(this, arguments);\n    if (!shouldPropagate) return;\n    var parent = this.$parent;\n    var args = toArray(arguments);\n    // use object event to indicate non-source emit\n    // on parents\n    args[0] = { name: event, source: this };\n    while (parent) {\n      shouldPropagate = parent.$emit.apply(parent, args);\n      parent = shouldPropagate ? parent.$parent : null;\n    }\n    return this;\n  };\n\n  /**\n   * Modify the listener counts on all parents.\n   * This bookkeeping allows $broadcast to return early when\n   * no child has listened to a certain event.\n   *\n   * @param {Vue} vm\n   * @param {String} event\n   * @param {Number} count\n   */\n\n  var hookRE = /^hook:/;\n  function modifyListenerCount(vm, event, count) {\n    var parent = vm.$parent;\n    // hooks do not get broadcasted so no need\n    // to do bookkeeping for them\n    if (!parent || !count || hookRE.test(event)) return;\n    while (parent) {\n      parent._eventsCount[event] = (parent._eventsCount[event] || 0) + count;\n      parent = parent.$parent;\n    }\n  }\n}\n\nfunction lifecycleAPI (Vue) {\n  /**\n   * Set instance target element and kick off the compilation\n   * process. The passed in `el` can be a selector string, an\n   * existing Element, or a DocumentFragment (for block\n   * instances).\n   *\n   * @param {Element|DocumentFragment|string} el\n   * @public\n   */\n\n  Vue.prototype.$mount = function (el) {\n    if (this._isCompiled) {\n      process.env.NODE_ENV !== 'production' && warn('$mount() should be called only once.');\n      return;\n    }\n    el = query(el);\n    if (!el) {\n      el = document.createElement('div');\n    }\n    this._compile(el);\n    this._initDOMHooks();\n    if (inDoc(this.$el)) {\n      this._callHook('attached');\n      ready.call(this);\n    } else {\n      this.$once('hook:attached', ready);\n    }\n    return this;\n  };\n\n  /**\n   * Mark an instance as ready.\n   */\n\n  function ready() {\n    this._isAttached = true;\n    this._isReady = true;\n    this._callHook('ready');\n  }\n\n  /**\n   * Teardown the instance, simply delegate to the internal\n   * _destroy.\n   */\n\n  Vue.prototype.$destroy = function (remove, deferCleanup) {\n    this._destroy(remove, deferCleanup);\n  };\n\n  /**\n   * Partially compile a piece of DOM and return a\n   * decompile function.\n   *\n   * @param {Element|DocumentFragment} el\n   * @param {Vue} [host]\n   * @return {Function}\n   */\n\n  Vue.prototype.$compile = function (el, host, scope, frag) {\n    return compile(el, this.$options, true)(this, el, host, scope, frag);\n  };\n}\n\n/**\n * The exposed Vue constructor.\n *\n * API conventions:\n * - public API methods/properties are prefixed with `$`\n * - internal methods/properties are prefixed with `_`\n * - non-prefixed properties are assumed to be proxied user\n *   data.\n *\n * @constructor\n * @param {Object} [options]\n * @public\n */\n\nfunction Vue(options) {\n  this._init(options);\n}\n\n// install internals\ninitMixin(Vue);\nstateMixin(Vue);\neventsMixin(Vue);\nlifecycleMixin(Vue);\nmiscMixin(Vue);\n\n// install instance APIs\ndataAPI(Vue);\ndomAPI(Vue);\neventsAPI(Vue);\nlifecycleAPI(Vue);\n\nvar slot = {\n\n  priority: SLOT,\n  params: ['name'],\n\n  bind: function bind() {\n    // this was resolved during component transclusion\n    var name = this.params.name || 'default';\n    var content = this.vm._slotContents && this.vm._slotContents[name];\n    if (!content || !content.hasChildNodes()) {\n      this.fallback();\n    } else {\n      this.compile(content.cloneNode(true), this.vm._context, this.vm);\n    }\n  },\n\n  compile: function compile(content, context, host) {\n    if (content && context) {\n      if (this.el.hasChildNodes() && content.childNodes.length === 1 && content.childNodes[0].nodeType === 1 && content.childNodes[0].hasAttribute('v-if')) {\n        // if the inserted slot has v-if\n        // inject fallback content as the v-else\n        var elseBlock = document.createElement('template');\n        elseBlock.setAttribute('v-else', '');\n        elseBlock.innerHTML = this.el.innerHTML;\n        // the else block should be compiled in child scope\n        elseBlock._context = this.vm;\n        content.appendChild(elseBlock);\n      }\n      var scope = host ? host._scope : this._scope;\n      this.unlink = context.$compile(content, host, scope, this._frag);\n    }\n    if (content) {\n      replace(this.el, content);\n    } else {\n      remove(this.el);\n    }\n  },\n\n  fallback: function fallback() {\n    this.compile(extractContent(this.el, true), this.vm);\n  },\n\n  unbind: function unbind() {\n    if (this.unlink) {\n      this.unlink();\n    }\n  }\n};\n\nvar partial = {\n\n  priority: PARTIAL,\n\n  params: ['name'],\n\n  // watch changes to name for dynamic partials\n  paramWatchers: {\n    name: function name(value) {\n      vIf.remove.call(this);\n      if (value) {\n        this.insert(value);\n      }\n    }\n  },\n\n  bind: function bind() {\n    this.anchor = createAnchor('v-partial');\n    replace(this.el, this.anchor);\n    this.insert(this.params.name);\n  },\n\n  insert: function insert(id) {\n    var partial = resolveAsset(this.vm.$options, 'partials', id);\n    if (process.env.NODE_ENV !== 'production') {\n      assertAsset(partial, 'partial', id);\n    }\n    if (partial) {\n      this.factory = new FragmentFactory(this.vm, partial);\n      vIf.insert.call(this);\n    }\n  },\n\n  unbind: function unbind() {\n    if (this.frag) {\n      this.frag.destroy();\n    }\n  }\n};\n\nvar elementDirectives = {\n  slot: slot,\n  partial: partial\n};\n\nvar convertArray = vFor._postProcess;\n\n/**\n * Limit filter for arrays\n *\n * @param {Number} n\n * @param {Number} offset (Decimal expected)\n */\n\nfunction limitBy(arr, n, offset) {\n  offset = offset ? parseInt(offset, 10) : 0;\n  n = toNumber(n);\n  return typeof n === 'number' ? arr.slice(offset, offset + n) : arr;\n}\n\n/**\n * Filter filter for arrays\n *\n * @param {String} search\n * @param {String} [delimiter]\n * @param {String} ...dataKeys\n */\n\nfunction filterBy(arr, search, delimiter) {\n  arr = convertArray(arr);\n  if (search == null) {\n    return arr;\n  }\n  if (typeof search === 'function') {\n    return arr.filter(search);\n  }\n  // cast to lowercase string\n  search = ('' + search).toLowerCase();\n  // allow optional `in` delimiter\n  // because why not\n  var n = delimiter === 'in' ? 3 : 2;\n  // extract and flatten keys\n  var keys = toArray(arguments, n).reduce(function (prev, cur) {\n    return prev.concat(cur);\n  }, []);\n  var res = [];\n  var item, key, val, j;\n  for (var i = 0, l = arr.length; i < l; i++) {\n    item = arr[i];\n    val = item && item.$value || item;\n    j = keys.length;\n    if (j) {\n      while (j--) {\n        key = keys[j];\n        if (key === '$key' && contains$1(item.$key, search) || contains$1(getPath(val, key), search)) {\n          res.push(item);\n          break;\n        }\n      }\n    } else if (contains$1(item, search)) {\n      res.push(item);\n    }\n  }\n  return res;\n}\n\n/**\n * Filter filter for arrays\n *\n * @param {String} sortKey\n * @param {String} reverse\n */\n\nfunction orderBy(arr, sortKey, reverse) {\n  arr = convertArray(arr);\n  if (!sortKey) {\n    return arr;\n  }\n  var order = reverse && reverse < 0 ? -1 : 1;\n  // sort on a copy to avoid mutating original array\n  return arr.slice().sort(function (a, b) {\n    if (sortKey !== '$key') {\n      if (isObject(a) && '$value' in a) a = a.$value;\n      if (isObject(b) && '$value' in b) b = b.$value;\n    }\n    a = isObject(a) ? getPath(a, sortKey) : a;\n    b = isObject(b) ? getPath(b, sortKey) : b;\n    return a === b ? 0 : a > b ? order : -order;\n  });\n}\n\n/**\n * String contain helper\n *\n * @param {*} val\n * @param {String} search\n */\n\nfunction contains$1(val, search) {\n  var i;\n  if (isPlainObject(val)) {\n    var keys = Object.keys(val);\n    i = keys.length;\n    while (i--) {\n      if (contains$1(val[keys[i]], search)) {\n        return true;\n      }\n    }\n  } else if (isArray(val)) {\n    i = val.length;\n    while (i--) {\n      if (contains$1(val[i], search)) {\n        return true;\n      }\n    }\n  } else if (val != null) {\n    return val.toString().toLowerCase().indexOf(search) > -1;\n  }\n}\n\nvar digitsRE = /(\\d{3})(?=\\d)/g;\n\n// asset collections must be a plain object.\nvar filters = {\n\n  orderBy: orderBy,\n  filterBy: filterBy,\n  limitBy: limitBy,\n\n  /**\n   * Stringify value.\n   *\n   * @param {Number} indent\n   */\n\n  json: {\n    read: function read(value, indent) {\n      return typeof value === 'string' ? value : JSON.stringify(value, null, Number(indent) || 2);\n    },\n    write: function write(value) {\n      try {\n        return JSON.parse(value);\n      } catch (e) {\n        return value;\n      }\n    }\n  },\n\n  /**\n   * 'abc' => 'Abc'\n   */\n\n  capitalize: function capitalize(value) {\n    if (!value && value !== 0) return '';\n    value = value.toString();\n    return value.charAt(0).toUpperCase() + value.slice(1);\n  },\n\n  /**\n   * 'abc' => 'ABC'\n   */\n\n  uppercase: function uppercase(value) {\n    return value || value === 0 ? value.toString().toUpperCase() : '';\n  },\n\n  /**\n   * 'AbC' => 'abc'\n   */\n\n  lowercase: function lowercase(value) {\n    return value || value === 0 ? value.toString().toLowerCase() : '';\n  },\n\n  /**\n   * 12345 => $12,345.00\n   *\n   * @param {String} sign\n   */\n\n  currency: function currency(value, _currency) {\n    value = parseFloat(value);\n    if (!isFinite(value) || !value && value !== 0) return '';\n    _currency = _currency != null ? _currency : '$';\n    var stringified = Math.abs(value).toFixed(2);\n    var _int = stringified.slice(0, -3);\n    var i = _int.length % 3;\n    var head = i > 0 ? _int.slice(0, i) + (_int.length > 3 ? ',' : '') : '';\n    var _float = stringified.slice(-3);\n    var sign = value < 0 ? '-' : '';\n    return sign + _currency + head + _int.slice(i).replace(digitsRE, '$1,') + _float;\n  },\n\n  /**\n   * 'item' => 'items'\n   *\n   * @params\n   *  an array of strings corresponding to\n   *  the single, double, triple ... forms of the word to\n   *  be pluralized. When the number to be pluralized\n   *  exceeds the length of the args, it will use the last\n   *  entry in the array.\n   *\n   *  e.g. ['single', 'double', 'triple', 'multiple']\n   */\n\n  pluralize: function pluralize(value) {\n    var args = toArray(arguments, 1);\n    return args.length > 1 ? args[value % 10 - 1] || args[args.length - 1] : args[0] + (value === 1 ? '' : 's');\n  },\n\n  /**\n   * Debounce a handler function.\n   *\n   * @param {Function} handler\n   * @param {Number} delay = 300\n   * @return {Function}\n   */\n\n  debounce: function debounce(handler, delay) {\n    if (!handler) return;\n    if (!delay) {\n      delay = 300;\n    }\n    return _debounce(handler, delay);\n  }\n};\n\nfunction installGlobalAPI (Vue) {\n  /**\n   * Vue and every constructor that extends Vue has an\n   * associated options object, which can be accessed during\n   * compilation steps as `this.constructor.options`.\n   *\n   * These can be seen as the default options of every\n   * Vue instance.\n   */\n\n  Vue.options = {\n    directives: directives,\n    elementDirectives: elementDirectives,\n    filters: filters,\n    transitions: {},\n    components: {},\n    partials: {},\n    replace: true\n  };\n\n  /**\n   * Expose useful internals\n   */\n\n  Vue.util = util;\n  Vue.config = config;\n  Vue.set = set;\n  Vue['delete'] = del;\n  Vue.nextTick = nextTick;\n\n  /**\n   * The following are exposed for advanced usage / plugins\n   */\n\n  Vue.compiler = compiler;\n  Vue.FragmentFactory = FragmentFactory;\n  Vue.internalDirectives = internalDirectives;\n  Vue.parsers = {\n    path: path,\n    text: text,\n    template: template,\n    directive: directive,\n    expression: expression\n  };\n\n  /**\n   * Each instance constructor, including Vue, has a unique\n   * cid. This enables us to create wrapped \"child\n   * constructors\" for prototypal inheritance and cache them.\n   */\n\n  Vue.cid = 0;\n  var cid = 1;\n\n  /**\n   * Class inheritance\n   *\n   * @param {Object} extendOptions\n   */\n\n  Vue.extend = function (extendOptions) {\n    extendOptions = extendOptions || {};\n    var Super = this;\n    var isFirstExtend = Super.cid === 0;\n    if (isFirstExtend && extendOptions._Ctor) {\n      return extendOptions._Ctor;\n    }\n    var name = extendOptions.name || Super.options.name;\n    if (process.env.NODE_ENV !== 'production') {\n      if (!/^[a-zA-Z][\\w-]*$/.test(name)) {\n        warn('Invalid component name: \"' + name + '\". Component names ' + 'can only contain alphanumeric characaters and the hyphen.');\n        name = null;\n      }\n    }\n    var Sub = createClass(name || 'VueComponent');\n    Sub.prototype = Object.create(Super.prototype);\n    Sub.prototype.constructor = Sub;\n    Sub.cid = cid++;\n    Sub.options = mergeOptions(Super.options, extendOptions);\n    Sub['super'] = Super;\n    // allow further extension\n    Sub.extend = Super.extend;\n    // create asset registers, so extended classes\n    // can have their private assets too.\n    config._assetTypes.forEach(function (type) {\n      Sub[type] = Super[type];\n    });\n    // enable recursive self-lookup\n    if (name) {\n      Sub.options.components[name] = Sub;\n    }\n    // cache constructor\n    if (isFirstExtend) {\n      extendOptions._Ctor = Sub;\n    }\n    return Sub;\n  };\n\n  /**\n   * A function that returns a sub-class constructor with the\n   * given name. This gives us much nicer output when\n   * logging instances in the console.\n   *\n   * @param {String} name\n   * @return {Function}\n   */\n\n  function createClass(name) {\n    /* eslint-disable no-new-func */\n    return new Function('return function ' + classify(name) + ' (options) { this._init(options) }')();\n    /* eslint-enable no-new-func */\n  }\n\n  /**\n   * Plugin system\n   *\n   * @param {Object} plugin\n   */\n\n  Vue.use = function (plugin) {\n    /* istanbul ignore if */\n    if (plugin.installed) {\n      return;\n    }\n    // additional parameters\n    var args = toArray(arguments, 1);\n    args.unshift(this);\n    if (typeof plugin.install === 'function') {\n      plugin.install.apply(plugin, args);\n    } else {\n      plugin.apply(null, args);\n    }\n    plugin.installed = true;\n    return this;\n  };\n\n  /**\n   * Apply a global mixin by merging it into the default\n   * options.\n   */\n\n  Vue.mixin = function (mixin) {\n    Vue.options = mergeOptions(Vue.options, mixin);\n  };\n\n  /**\n   * Create asset registration methods with the following\n   * signature:\n   *\n   * @param {String} id\n   * @param {*} definition\n   */\n\n  config._assetTypes.forEach(function (type) {\n    Vue[type] = function (id, definition) {\n      if (!definition) {\n        return this.options[type + 's'][id];\n      } else {\n        /* istanbul ignore if */\n        if (process.env.NODE_ENV !== 'production') {\n          if (type === 'component' && (commonTagRE.test(id) || reservedTagRE.test(id))) {\n            warn('Do not use built-in or reserved HTML elements as component ' + 'id: ' + id);\n          }\n        }\n        if (type === 'component' && isPlainObject(definition)) {\n          definition.name = id;\n          definition = Vue.extend(definition);\n        }\n        this.options[type + 's'][id] = definition;\n        return definition;\n      }\n    };\n  });\n\n  // expose internal transition API\n  extend(Vue.transition, transition);\n}\n\ninstallGlobalAPI(Vue);\n\nVue.version = '1.0.17';\n\n// devtools global hook\n/* istanbul ignore next */\nif (devtools) {\n  devtools.emit('init', Vue);\n} else if (process.env.NODE_ENV !== 'production' && inBrowser && /Chrome\\/\\d+/.test(window.navigator.userAgent)) {\n  console.log('Download the Vue Devtools for a better development experience:\\n' + 'https://github.com/vuejs/vue-devtools');\n}\n\nmodule.exports = Vue;","var inserted = exports.cache = {}\n\nexports.insert = function (css) {\n  if (inserted[css]) return\n  inserted[css] = true\n\n  var elem = document.createElement('style')\n  elem.setAttribute('type', 'text/css')\n\n  if ('textContent' in elem) {\n    elem.textContent = css\n  } else {\n    elem.styleSheet.cssText = css\n  }\n\n  document.getElementsByTagName('head')[0].appendChild(elem)\n  return elem\n}\n","/*!\n * Vuex v0.6.2\n * (c) 2016 Evan You\n * Released under the MIT License.\n */\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global.Vuex = factory());\n}(this, function () { 'use strict';\n\n  var babelHelpers = {};\n  babelHelpers.typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && typeof Symbol === \"function\" && obj.constructor === Symbol ? \"symbol\" : typeof obj;\n  };\n\n  babelHelpers.classCallCheck = function (instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n      throw new TypeError(\"Cannot call a class as a function\");\n    }\n  };\n\n  babelHelpers.createClass = function () {\n    function defineProperties(target, props) {\n      for (var i = 0; i < props.length; i++) {\n        var descriptor = props[i];\n        descriptor.enumerable = descriptor.enumerable || false;\n        descriptor.configurable = true;\n        if (\"value\" in descriptor) descriptor.writable = true;\n        Object.defineProperty(target, descriptor.key, descriptor);\n      }\n    }\n\n    return function (Constructor, protoProps, staticProps) {\n      if (protoProps) defineProperties(Constructor.prototype, protoProps);\n      if (staticProps) defineProperties(Constructor, staticProps);\n      return Constructor;\n    };\n  }();\n\n  babelHelpers.toConsumableArray = function (arr) {\n    if (Array.isArray(arr)) {\n      for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n      return arr2;\n    } else {\n      return Array.from(arr);\n    }\n  };\n\n  babelHelpers;\n\n  /**\n   * Merge an array of objects into one.\n   *\n   * @param {Array<Object>} arr\n   * @return {Object}\n   */\n\n  function mergeObjects(arr) {\n    return arr.reduce(function (prev, obj) {\n      Object.keys(obj).forEach(function (key) {\n        var existing = prev[key];\n        if (existing) {\n          // allow multiple mutation objects to contain duplicate\n          // handlers for the same mutation type\n          if (Array.isArray(existing)) {\n            existing.push(obj[key]);\n          } else {\n            prev[key] = [prev[key], obj[key]];\n          }\n        } else {\n          prev[key] = obj[key];\n        }\n      });\n      return prev;\n    }, {});\n  }\n\n  /**\n   * Deep clone an object. Faster than JSON.parse(JSON.stringify()).\n   *\n   * @param {*} obj\n   * @return {*}\n   */\n\n  function deepClone(obj) {\n    if (Array.isArray(obj)) {\n      return obj.map(deepClone);\n    } else if (obj && (typeof obj === 'undefined' ? 'undefined' : babelHelpers.typeof(obj)) === 'object') {\n      var cloned = {};\n      var keys = Object.keys(obj);\n      for (var i = 0, l = keys.length; i < l; i++) {\n        var key = keys[i];\n        cloned[key] = deepClone(obj[key]);\n      }\n      return cloned;\n    } else {\n      return obj;\n    }\n  }\n\n  /**\n   * Hacks to get access to Vue internals.\n   * Maybe we should expose these...\n   */\n\n  var Watcher = void 0;\n  function getWatcher(vm) {\n    if (!Watcher) {\n      var unwatch = vm.$watch('__vuex__', function (a) {\n        return a;\n      });\n      Watcher = vm._watchers[0].constructor;\n      unwatch();\n    }\n    return Watcher;\n  }\n\n  var Dep = void 0;\n  function getDep(vm) {\n    if (!Dep) {\n      Dep = vm._data.__ob__.dep.constructor;\n    }\n    return Dep;\n  }\n\n  var hook = typeof window !== 'undefined' && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n  var devtoolMiddleware = {\n    onInit: function onInit(state, store) {\n      if (!hook) return;\n      hook.emit('vuex:init', store);\n      hook.on('vuex:travel-to-state', function (targetState) {\n        var currentState = store._vm._data;\n        store._dispatching = true;\n        Object.keys(targetState).forEach(function (key) {\n          currentState[key] = targetState[key];\n        });\n        store._dispatching = false;\n      });\n    },\n    onMutation: function onMutation(mutation, state) {\n      if (!hook) return;\n      hook.emit('vuex:mutation', mutation, state);\n    }\n  };\n\n  function override (Vue) {\n    // override init and inject vuex init procedure\n    var _init = Vue.prototype._init;\n    Vue.prototype._init = function () {\n      var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n      options.init = options.init ? [vuexInit].concat(options.init) : vuexInit;\n      _init.call(this, options);\n    };\n\n    function vuexInit() {\n      var options = this.$options;\n      var store = options.store;\n      var vuex = options.vuex;\n      // store injection\n\n      if (store) {\n        this.$store = store;\n      } else if (options.parent && options.parent.$store) {\n        this.$store = options.parent.$store;\n      }\n      // vuex option handling\n      if (vuex) {\n        if (!this.$store) {\n          console.warn('[vuex] store not injected. make sure to ' + 'provide the store option in your root component.');\n        }\n        var state = vuex.state;\n        var getters = vuex.getters;\n        var actions = vuex.actions;\n        // handle deprecated state option\n\n        if (state && !getters) {\n          console.warn('[vuex] vuex.state option will been deprecated in 1.0. ' + 'Use vuex.getters instead.');\n          getters = state;\n        }\n        // getters\n        if (getters) {\n          options.computed = options.computed || {};\n          for (var key in getters) {\n            defineVuexGetter(this, key, getters[key]);\n          }\n        }\n        // actions\n        if (actions) {\n          options.methods = options.methods || {};\n          for (var _key in actions) {\n            options.methods[_key] = makeBoundAction(actions[_key], this.$store);\n          }\n        }\n      }\n    }\n\n    function setter() {\n      throw new Error('vuex getter properties are read-only.');\n    }\n\n    function defineVuexGetter(vm, key, getter) {\n      Object.defineProperty(vm, key, {\n        enumerable: true,\n        configurable: true,\n        get: makeComputedGetter(vm.$store, getter),\n        set: setter\n      });\n    }\n\n    function makeComputedGetter(store, getter) {\n      var id = store._getterCacheId;\n      // cached\n      if (getter[id]) {\n        return getter[id];\n      }\n      var vm = store._vm;\n      var Watcher = getWatcher(vm);\n      var Dep = getDep(vm);\n      var watcher = new Watcher(vm, function (state) {\n        return getter(state);\n      }, null, { lazy: true });\n      var computedGetter = function computedGetter() {\n        if (watcher.dirty) {\n          watcher.evaluate();\n        }\n        if (Dep.target) {\n          watcher.depend();\n        }\n        return watcher.value;\n      };\n      getter[id] = computedGetter;\n      return computedGetter;\n    }\n\n    function makeBoundAction(action, store) {\n      return function vuexBoundAction() {\n        for (var _len = arguments.length, args = Array(_len), _key2 = 0; _key2 < _len; _key2++) {\n          args[_key2] = arguments[_key2];\n        }\n\n        return action.call.apply(action, [this, store].concat(args));\n      };\n    }\n\n    // option merging\n    var merge = Vue.config.optionMergeStrategies.computed;\n    Vue.config.optionMergeStrategies.vuex = function (toVal, fromVal) {\n      if (!toVal) return fromVal;\n      if (!fromVal) return toVal;\n      return {\n        getters: merge(toVal.getters, fromVal.getters),\n        state: merge(toVal.state, fromVal.state),\n        actions: merge(toVal.actions, fromVal.actions)\n      };\n    };\n  }\n\n  var Vue = void 0;\n  var uid = 0;\n\n  var Store = function () {\n\n    /**\n     * @param {Object} options\n     *        - {Object} state\n     *        - {Object} actions\n     *        - {Object} mutations\n     *        - {Array} middlewares\n     *        - {Boolean} strict\n     */\n\n    function Store() {\n      var _this = this;\n\n      var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n      var _ref$state = _ref.state;\n      var state = _ref$state === undefined ? {} : _ref$state;\n      var _ref$mutations = _ref.mutations;\n      var mutations = _ref$mutations === undefined ? {} : _ref$mutations;\n      var _ref$modules = _ref.modules;\n      var modules = _ref$modules === undefined ? {} : _ref$modules;\n      var _ref$middlewares = _ref.middlewares;\n      var middlewares = _ref$middlewares === undefined ? [] : _ref$middlewares;\n      var _ref$strict = _ref.strict;\n      var strict = _ref$strict === undefined ? false : _ref$strict;\n      babelHelpers.classCallCheck(this, Store);\n\n      this._getterCacheId = 'vuex_store_' + uid++;\n      this._dispatching = false;\n      this._rootMutations = this._mutations = mutations;\n      this._modules = modules;\n      // bind dispatch to self\n      var dispatch = this.dispatch;\n      this.dispatch = function () {\n        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n          args[_key] = arguments[_key];\n        }\n\n        dispatch.apply(_this, args);\n      };\n      // use a Vue instance to store the state tree\n      // suppress warnings just in case the user has added\n      // some funky global mixins\n      if (!Vue) {\n        throw new Error('[vuex] must call Vue.use(Vuex) before creating a store instance.');\n      }\n      var silent = Vue.config.silent;\n      Vue.config.silent = true;\n      this._vm = new Vue({\n        data: state\n      });\n      Vue.config.silent = silent;\n      this._setupModuleState(state, modules);\n      this._setupModuleMutations(modules);\n      this._setupMiddlewares(middlewares, state);\n      // add extra warnings in strict mode\n      if (strict) {\n        this._setupMutationCheck();\n      }\n    }\n\n    /**\n     * Getter for the entire state tree.\n     * Read only.\n     *\n     * @return {Object}\n     */\n\n    babelHelpers.createClass(Store, [{\n      key: 'dispatch',\n\n\n      /**\n       * Dispatch an action.\n       *\n       * @param {String} type\n       */\n\n      value: function dispatch(type) {\n        var _this2 = this;\n\n        for (var _len2 = arguments.length, payload = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n          payload[_key2 - 1] = arguments[_key2];\n        }\n\n        // compatibility for object actions, e.g. FSA\n        if ((typeof type === 'undefined' ? 'undefined' : babelHelpers.typeof(type)) === 'object' && type.type && arguments.length === 1) {\n          payload = [type];\n          type = type.type;\n        }\n        var mutation = this._mutations[type];\n        var prevSnapshot = this._prevSnapshot;\n        var state = this.state;\n        var snapshot = void 0,\n            clonedPayload = void 0;\n        if (mutation) {\n          this._dispatching = true;\n          // apply the mutation\n          if (Array.isArray(mutation)) {\n            mutation.forEach(function (m) {\n              return m.apply(undefined, [state].concat(babelHelpers.toConsumableArray(payload)));\n            });\n          } else {\n            mutation.apply(undefined, [state].concat(babelHelpers.toConsumableArray(payload)));\n          }\n          this._dispatching = false;\n          // invoke middlewares\n          if (this._needSnapshots) {\n            snapshot = this._prevSnapshot = deepClone(state);\n            clonedPayload = deepClone(payload);\n          }\n          this._middlewares.forEach(function (m) {\n            if (m.onMutation) {\n              if (m.snapshot) {\n                m.onMutation({ type: type, payload: clonedPayload }, snapshot, prevSnapshot, _this2);\n              } else {\n                m.onMutation({ type: type, payload: payload }, state, _this2);\n              }\n            }\n          });\n        } else {\n          console.warn('[vuex] Unknown mutation: ' + type);\n        }\n      }\n\n      /**\n       * Watch state changes on the store.\n       * Same API as Vue's $watch, except when watching a function,\n       * the function gets the state as the first argument.\n       *\n       * @param {String|Function} expOrFn\n       * @param {Function} cb\n       * @param {Object} [options]\n       */\n\n    }, {\n      key: 'watch',\n      value: function watch(expOrFn, cb, options) {\n        var _this3 = this;\n\n        return this._vm.$watch(function () {\n          return typeof expOrFn === 'function' ? expOrFn(_this3.state) : _this3._vm.$get(expOrFn);\n        }, cb, options);\n      }\n\n      /**\n       * Hot update mutations & modules.\n       *\n       * @param {Object} options\n       *        - {Object} [mutations]\n       *        - {Object} [modules]\n       */\n\n    }, {\n      key: 'hotUpdate',\n      value: function hotUpdate() {\n        var _ref2 = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n        var mutations = _ref2.mutations;\n        var modules = _ref2.modules;\n\n        this._rootMutations = this._mutations = mutations || this._rootMutations;\n        this._setupModuleMutations(modules || this._modules);\n      }\n\n      /**\n       * Attach sub state tree of each module to the root tree.\n       *\n       * @param {Object} state\n       * @param {Object} modules\n       */\n\n    }, {\n      key: '_setupModuleState',\n      value: function _setupModuleState(state, modules) {\n        var setPath = Vue.parsers.path.setPath;\n\n        Object.keys(modules).forEach(function (key) {\n          setPath(state, key, modules[key].state || {});\n        });\n      }\n\n      /**\n       * Bind mutations for each module to its sub tree and\n       * merge them all into one final mutations map.\n       *\n       * @param {Object} updatedModules\n       */\n\n    }, {\n      key: '_setupModuleMutations',\n      value: function _setupModuleMutations(updatedModules) {\n        var modules = this._modules;\n        var getPath = Vue.parsers.path.getPath;\n\n        var allMutations = [this._rootMutations];\n        Object.keys(updatedModules).forEach(function (key) {\n          modules[key] = updatedModules[key];\n        });\n        Object.keys(modules).forEach(function (key) {\n          var module = modules[key];\n          if (!module || !module.mutations) return;\n          // bind mutations to sub state tree\n          var mutations = {};\n          Object.keys(module.mutations).forEach(function (name) {\n            var original = module.mutations[name];\n            mutations[name] = function (state) {\n              for (var _len3 = arguments.length, args = Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {\n                args[_key3 - 1] = arguments[_key3];\n              }\n\n              original.apply(undefined, [getPath(state, key)].concat(args));\n            };\n          });\n          allMutations.push(mutations);\n        });\n        this._mutations = mergeObjects(allMutations);\n      }\n\n      /**\n       * Setup mutation check: if the vuex instance's state is mutated\n       * outside of a mutation handler, we throw en error. This effectively\n       * enforces all mutations to the state to be trackable and hot-reloadble.\n       * However, this comes at a run time cost since we are doing a deep\n       * watch on the entire state tree, so it is only enalbed with the\n       * strict option is set to true.\n       */\n\n    }, {\n      key: '_setupMutationCheck',\n      value: function _setupMutationCheck() {\n        var _this4 = this;\n\n        var Watcher = getWatcher(this._vm);\n        /* eslint-disable no-new */\n        new Watcher(this._vm, '$data', function () {\n          if (!_this4._dispatching) {\n            throw new Error('[vuex] Do not mutate vuex store state outside mutation handlers.');\n          }\n        }, { deep: true, sync: true });\n        /* eslint-enable no-new */\n      }\n\n      /**\n       * Setup the middlewares. The devtools middleware is always\n       * included, since it does nothing if no devtool is detected.\n       *\n       * A middleware can demand the state it receives to be\n       * \"snapshots\", i.e. deep clones of the actual state tree.\n       *\n       * @param {Array} middlewares\n       * @param {Object} state\n       */\n\n    }, {\n      key: '_setupMiddlewares',\n      value: function _setupMiddlewares(middlewares, state) {\n        var _this5 = this;\n\n        this._middlewares = [devtoolMiddleware].concat(middlewares);\n        this._needSnapshots = middlewares.some(function (m) {\n          return m.snapshot;\n        });\n        if (this._needSnapshots) {\n          console.log('[vuex] One or more of your middlewares are taking state snapshots ' + 'for each mutation. Make sure to use them only during development.');\n        }\n        var initialSnapshot = this._prevSnapshot = this._needSnapshots ? deepClone(state) : null;\n        // call init hooks\n        this._middlewares.forEach(function (m) {\n          if (m.onInit) {\n            m.onInit(m.snapshot ? initialSnapshot : state, _this5);\n          }\n        });\n      }\n    }, {\n      key: 'state',\n      get: function get() {\n        return this._vm._data;\n      },\n      set: function set(v) {\n        throw new Error('[vuex] Vuex root state is read only.');\n      }\n    }]);\n    return Store;\n  }();\n\n  function install(_Vue) {\n    Vue = _Vue;\n    override(Vue);\n  }\n\n  // auto install in dist mode\n  if (typeof window !== 'undefined' && window.Vue) {\n    install(window.Vue);\n  }\n\n  function createLogger() {\n    console.warn('[vuex] Vuex.createLogger has been deprecated.' + 'Use `import createLogger from \\'vuex/logger\\' instead.');\n  }\n\n  var index = {\n    Store: Store,\n    install: install,\n    createLogger: createLogger\n  };\n\n  return index;\n\n}));","'use strict';\n\nvar alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'.split('')\n  , length = 64\n  , map = {}\n  , seed = 0\n  , i = 0\n  , prev;\n\n/**\n * Return a string representing the specified number.\n *\n * @param {Number} num The number to convert.\n * @returns {String} The string representation of the number.\n * @api public\n */\nfunction encode(num) {\n  var encoded = '';\n\n  do {\n    encoded = alphabet[num % length] + encoded;\n    num = Math.floor(num / length);\n  } while (num > 0);\n\n  return encoded;\n}\n\n/**\n * Return the integer value specified by the given string.\n *\n * @param {String} str The string to convert.\n * @returns {Number} The integer value represented by the string.\n * @api public\n */\nfunction decode(str) {\n  var decoded = 0;\n\n  for (i = 0; i < str.length; i++) {\n    decoded = decoded * length + map[str.charAt(i)];\n  }\n\n  return decoded;\n}\n\n/**\n * Yeast: A tiny growing id generator.\n *\n * @returns {String} A unique id.\n * @api public\n */\nfunction yeast() {\n  var now = encode(+new Date());\n\n  if (now !== prev) return seed = 0, prev = now;\n  return now +'.'+ encode(seed++);\n}\n\n//\n// Map each character to its index.\n//\nfor (; i < length; i++) map[alphabet[i]] = i;\n\n//\n// Expose the `yeast`, `encode` and `decode` functions.\n//\nyeast.encode = encode;\nyeast.decode = decode;\nmodule.exports = yeast;\n","var __vueify_style__ = require(\"vueify-insert-css\").insert(\"\\n\\n/*  #F16745 #FFC65D #7BC8A4 #4CC3D9 #93648D #404040  */\\n\\n  body {\\n    color: #404040;\\n  }\\n\\n  .jumbotron-top {\\n    color: #fff;\\n    background: #4CC3D9;\\n    margin-bottom: 0;\\n  }\\n\\n  .btn-custom {\\n    color: #fff;\\n    background: #F16745;\\n  }\\n\\n  .jumbotron.jumbotron-green {\\n    padding: 75px 0;\\n    /*background: #404040;*/\\n    /*color: #fff;*/\\n  }\\n\\n  #v-select .dropdown-toggle {\\n    /*border-color:#fff;*/\\n    background: #fff;\\n  }\\n\\n  #v-select .dropdown-toggle:after {\\n    color: #404040;\\n  }\\n\\n  /* Cyan theme */\\n  #v-select .selected-tag {\\n    color: #147688;\\n    background-color: #d7f3f9;\\n    border-color: #91ddec;\\n  }\\n\\n  #v-select.dropdown.open .dropdown-toggle,\\n  #v-select.dropdown.open .dropdown-menu {\\n    border-color: #4CC3D9;\\n  }\\n\\n  #v-select .active a {\\n    background: rgba(50,50,50,.1);\\n    color: #333;\\n  }\\n\\n  #v-select.dropdown .highlight a,\\n  #v-select.dropdown li:hover a {\\n    background: #4CC3D9;\\n    color: #fff;\\n  }\\n\\n  #output {\\n    height: 200px;\\n    border: none;\\n    color: #404040;\\n  }\\n\")\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _Jumbotron = require('./components/Jumbotron.vue');\n\nvar _Jumbotron2 = _interopRequireDefault(_Jumbotron);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = {\n  components: { Jumbotron: _Jumbotron2.default }\n};\nif (module.exports.__esModule) module.exports = module.exports.default\n;(typeof module.exports === \"function\"? module.exports.options: module.exports).template = \"\\n<div class=\\\"jumbotron jumbotron-top\\\">\\n  <div class=\\\"container\\\">\\n    <h1>Vue Select</h1>\\n    <p class=\\\"lead\\\">A simple component that provides similar functionality to Select2 without the overhead of jQuery.</p>\\n    <a class=\\\"btn btn-custom\\\" href=\\\"https://github.com/sagalbot/vue-select\\\">View on GitHub</a>\\n  </div>\\n</div>\\n\\n  <jumbotron></jumbotron>\\n\\n  <div id=\\\"app\\\" class=\\\"container\\\">\\n  <h2 class=\\\"page-header\\\">Live Edit <small>play around with the above vue-select</small></h2>\\n\\n  <div class=\\\"row\\\">\\n    <div class=\\\"col-md-6\\\">\\n      <label class=\\\"control-label\\\">Options</label><br>\\n      <div class=\\\"radio\\\">\\n        <label for=\\\"advanced\\\">\\n          <input id=\\\"advanced\\\" type=\\\"radio\\\" v-model=\\\"optionType\\\" value=\\\"advanced\\\"> Objects\\n          <pre><code class=\\\"language-javascript\\\">[{value: 'foo', label: 'Foo'}]</code></pre>\\n        </label>\\n        <br>\\n        <label for=\\\"simple\\\">\\n          <input id=\\\"simple\\\" type=\\\"radio\\\" v-model=\\\"optionType\\\" value=\\\"simple\\\"> Strings\\n          <pre><code class=\\\"language-javascript\\\">['foo', 'bar']</code></pre>\\n        </label>\\n        <span class=\\\"help-block\\\">The <code>options</code> property is watched for changes, and the value is reset anytime the options change. This is useful if you have multiple selection boxes that depend on its ancestors values.</span>\\n      </div>\\n    </div>\\n\\n    <div class=\\\"col-md-6\\\">\\n\\n      <div class=\\\"form-group\\\">\\n        <label class=\\\"control-label\\\">Allow Multiple</label>\\n        <div class=\\\"checkbox\\\">\\n          <label class=\\\"control-label\\\">\\n            <input v-model=\\\"multiple\\\" type=\\\"checkbox\\\"> True\\n          </label>\\n          <span class=\\\"help-block\\\">Equivalent to the <code>multiple</code> attribute to a <code>&lt;select&gt;</code>. You'll want to clear any selections you have made before changing this option. It's not one that should be changed after render.</span>\\n        </div>\\n      </div>\\n\\n      <div class=\\\"form-group\\\">\\n        <label class=\\\"control-label\\\">Max Height</label>\\n        <input type=\\\"text\\\" v-model=\\\"maxHeight\\\" class=\\\"form-control\\\">\\n        <span class=\\\"help-block\\\">Limit the height of the dropdown menu.</span>\\n      </div>\\n\\n      <div class=\\\"form-group\\\">\\n        <label class=\\\"control-label\\\">Placeholder</label>\\n        <input type=\\\"text\\\" v-model=\\\"placeholder\\\" class=\\\"form-control\\\">\\n        <span class=\\\"help-block\\\">Equivalent to the <code>placeholder</code> attribute.</span>\\n      </div>\\n    </div>\\n  </div>\\n\\n  <div class=\\\"row\\\">\\n    <div class=\\\"col-md-6\\\">\\n      <h2 class=\\\"page-header\\\">Install &amp; Usage</h2>\\n      <h5>Install from GitHub using NPM</h5>\\n      <pre><code class=\\\"language-c-like\\\">$ npm install sagalbot/vue-select</code></pre>\\n\\n      <pre v-pre=\\\"\\\">  <code class=\\\"language-markup\\\">&lt;template&gt;\\n    &lt;div id=\\\"myApp\\\"&gt;\\n      &lt;v-select :value.sync=\\\"selected\\\" :options=\\\"options\\\"&gt;&lt;/v-select&gt;\\n    &lt;/div&gt;\\n  &lt;/template&gt;</code>\\n\\n  <code class=\\\"language-markup\\\">&lt;script&gt;</code>\\n    <code class=\\\"language-javascript\\\">import vSelect from 'vue-select'\\n    export default {\\n      components: {vSelect},\\n\\n      data() {\\n        return {\\n          selected: null,\\n          options: ['foo','bar','baz']\\n        }\\n      }\\n    }</code>\\n  <code class=\\\"language-markup\\\">&lt;/script&gt;</code>\\n      </pre>\\n    </div>\\n    <div class=\\\"col-md-6\\\">\\n      <h2 class=\\\"page-header\\\">Parameters</h2>\\n      <ul>\\n        <li>\\n          <code>value</code> Represents the currently selected value(s)\\n          <ul>\\n            <li>type: String</li>\\n            <li>required: true </li>\\n          </ul>\\n        </li>\\n\\n        <li>\\n          <code>options</code> An array of strings or objects to be used as dropdown choices. Supports <code>['foo','bar']</code> &amp; <code>[{label: 'Foo', value: 'foo'}]</code>. When using the <code>[{}]</code> syntax, the objects in the array can have as many properties as you need, as long as the object contains <code>value</code> and <code>label</code> keys.\\n          <ul>\\n            <li>type: Array</li>\\n            <li>default: []</li>\\n          </ul>\\n        </li>\\n\\n          <li>\\n            <code>maxHeight</code> Limit the height of the dropdown menu\\n            <ul>\\n              <li>type: String</li>\\n              <li>default: '400px'</li>\\n            </ul>\\n          </li>\\n\\n          <li>\\n            <code>searchable</code> Toggle filtering of options\\n            <ul>\\n              <li>type: Boolean</li>\\n              <li>default: true</li>\\n            </ul>\\n          </li>\\n\\n          <li>\\n            <code>multiple</code> Equivalent to <code>multiple</code> attribute on a <code>&lt;select&gt;</code>\\n              <ul>\\n                <li>type: Boolean</li>\\n                <li>default: true</li>\\n              </ul>\\n            </li>\\n\\n          <li>\\n            <code>placeholder</code> Equivalent to <code>placeholder</code> attribute on an <code>&lt;input&gt;</code>\\n            <ul>\\n              <li>type: String</li>\\n              <li>default: ''</li>\\n            </ul>\\n          </li>\\n\\n          <li>\\n            <code>transition</code> Vue <code>transition</code> prop applied to the <code>.dropdown-menu</code>\\n            <ul>\\n              <li>type: Boolean</li>\\n              <li>default: true</li>\\n            </ul>\\n          </li>\\n      </ul>\\n\\n    </div>\\n  </div>\\n\\n</div>\\n\"\nif (module.hot) {(function () {  module.hot.accept()\n  var hotAPI = require(\"vue-hot-reload-api\")\n  hotAPI.install(require(\"vue\"), true)\n  if (!hotAPI.compatible) return\n  var id = \"/Volumes/Documents/Dropbox/htdocs/vue-select/src/App.vue\"\n  module.hot.dispose(function () {\n    require(\"vueify-insert-css\").cache[\"\\n\\n/*  #F16745 #FFC65D #7BC8A4 #4CC3D9 #93648D #404040  */\\n\\n  body {\\n    color: #404040;\\n  }\\n\\n  .jumbotron-top {\\n    color: #fff;\\n    background: #4CC3D9;\\n    margin-bottom: 0;\\n  }\\n\\n  .btn-custom {\\n    color: #fff;\\n    background: #F16745;\\n  }\\n\\n  .jumbotron.jumbotron-green {\\n    padding: 75px 0;\\n    /*background: #404040;*/\\n    /*color: #fff;*/\\n  }\\n\\n  #v-select .dropdown-toggle {\\n    /*border-color:#fff;*/\\n    background: #fff;\\n  }\\n\\n  #v-select .dropdown-toggle:after {\\n    color: #404040;\\n  }\\n\\n  /* Cyan theme */\\n  #v-select .selected-tag {\\n    color: #147688;\\n    background-color: #d7f3f9;\\n    border-color: #91ddec;\\n  }\\n\\n  #v-select.dropdown.open .dropdown-toggle,\\n  #v-select.dropdown.open .dropdown-menu {\\n    border-color: #4CC3D9;\\n  }\\n\\n  #v-select .active a {\\n    background: rgba(50,50,50,.1);\\n    color: #333;\\n  }\\n\\n  #v-select.dropdown .highlight a,\\n  #v-select.dropdown li:hover a {\\n    background: #4CC3D9;\\n    color: #fff;\\n  }\\n\\n  #output {\\n    height: 200px;\\n    border: none;\\n    color: #404040;\\n  }\\n\"] = false\n    document.head.removeChild(__vueify_style__)\n  })\n  if (!module.hot.data) {\n    hotAPI.createRecord(id, module.exports)\n  } else {\n    hotAPI.update(id, module.exports, (typeof module.exports === \"function\" ? module.exports.options : module.exports).template)\n  }\n})()}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _Select = require('./Select.vue');\n\nvar _Select2 = _interopRequireDefault(_Select);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = {\n  components: { vSelect: _Select2.default },\n\n  data: function data() {\n    return {\n      select: null,\n      placeholder: 'Choose a Country',\n      multiple: true,\n      maxHeight: '400px',\n      options: {\n        advanced: require('../countries/countries.js'),\n        simple: require('../countries/simpleCountries.js'),\n        simpler: [{ label: 'This is Foo', value: 'foo' }, { label: 'This is Bar', value: 'bar' }, { label: 'This is Baz', value: 'baz' }]\n      },\n      optionType: 'simple'\n    };\n  }\n};\nif (module.exports.__esModule) module.exports = module.exports.default\n;(typeof module.exports === \"function\"? module.exports.options: module.exports).template = \"\\n<div class=\\\"jumbotron jumbotron-green\\\">\\n  <div class=\\\"container\\\">\\n    <div class=\\\"row\\\">\\n      <div class=\\\"col-md-6 col-md-offset-1\\\">\\n\\n        <v-select id=\\\"v-select\\\" :placeholder=\\\"placeholder\\\" :value.sync=\\\"select\\\" :options=\\\"options[optionType]\\\" :multiple=\\\"multiple\\\">\\n        </v-select>\\n\\n      </div>\\n\\n      <pre id=\\\"output\\\" class=\\\"col-md-4\\\">{{ select | json }}</pre>\\n    </div>\\n  </div>\\n</div>\\n\"\nif (module.hot) {(function () {  module.hot.accept()\n  var hotAPI = require(\"vue-hot-reload-api\")\n  hotAPI.install(require(\"vue\"), true)\n  if (!hotAPI.compatible) return\n  var id = \"/Volumes/Documents/Dropbox/htdocs/vue-select/src/components/Jumbotron.vue\"\n  if (!module.hot.data) {\n    hotAPI.createRecord(id, module.exports)\n  } else {\n    hotAPI.update(id, module.exports, (typeof module.exports === \"function\" ? module.exports.options : module.exports).template)\n  }\n})()}","var __vueify_style__ = require(\"vueify-insert-css\").insert(\"\\n.dropdown[_v-3d450ab6] {\\n  position: relative;\\n}\\n\\n.open .dropdown-toggle[_v-3d450ab6],\\n.open .dropdown-menu[_v-3d450ab6] {\\n  border-color: rgba(60,60,60,.26);\\n}\\n\\n.open-indicator[_v-3d450ab6] {\\n  position: absolute;\\n  top: 10px;\\n  right: 10px;\\n  display: inline-block;\\n  cursor: pointer;\\n  pointer-events: all;\\n  -webkit-transition: all 150ms cubic-bezier(1.000, -0.115, 0.975, 0.855);\\n  transition: all 150ms cubic-bezier(1.000, -0.115, 0.975, 0.855);\\n  -webkit-transition-timing-function: cubic-bezier(1.000, -0.115, 0.975, 0.855);\\n          transition-timing-function: cubic-bezier(1.000, -0.115, 0.975, 0.855);\\n}\\n\\n.open .open-indicator[_v-3d450ab6] {\\n  -webkit-transform: rotate(180deg);\\n          transform: rotate(180deg);\\n}\\n\\n.dropdown-toggle[_v-3d450ab6] {\\n  display: block;\\n  padding: 0;\\n  background: none;\\n  border: 1px solid rgba(60,60,60,.26);\\n  border-radius: 4px;\\n  white-space: normal;\\n}\\n.searchable .dropdown-toggle[_v-3d450ab6] {\\n  cursor: text;\\n}\\n\\n.open .dropdown-toggle[_v-3d450ab6] {\\n  border-bottom: none;\\n  border-bottom-left-radius: 0;\\n  border-bottom-right-radius: 0;\\n}\\n\\n.dropdown-menu[_v-3d450ab6] {\\n  margin: 0;\\n  width: 100%;\\n  overflow-y: scroll;\\n  border-top: none;\\n  border-top-left-radius: 0;\\n  border-top-right-radius: 0;\\n}\\n\\n.selected-tag[_v-3d450ab6] {\\n  color: #333;\\n  background-color: #f0f0f0;\\n  border: 1px solid #ccc;\\n  border-radius: 4px;\\n  height: 26px;\\n  margin: 4px 1px 0px 3px;\\n  padding: 0 0.25em;\\n  float: left;\\n  line-height: 1.7em;\\n}\\n\\n.selected-tag .close[_v-3d450ab6] {\\n  float: none;\\n  margin-right: 0;\\n  font-size: 20px;\\n}\\n\\ninput[type=search][_v-3d450ab6],\\ninput[type=search][_v-3d450ab6]:focus {\\n  display: inline-block;\\n  border: none;\\n  outline: none;\\n  margin: 0;\\n  width: 10em;\\n  max-width: 100%;\\n  background: none;\\n  position: relative;\\n  box-shadow: none;\\n  float: left;\\n  clear: none;\\n}\\n\\ninput[type=search][_v-3d450ab6]:disabled {\\n  cursor: pointer;\\n}\\n\\nli a[_v-3d450ab6] {\\n  cursor: pointer;\\n}\\n\\n.active a[_v-3d450ab6] {\\n  background: rgba(50,50,50,.1);\\n  color: #333;\\n}\\n\\n.highlight a[_v-3d450ab6],\\nli:hover a[_v-3d450ab6] {\\n  background: #f0f0f0;\\n  color: #333;\\n}\\n\")\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _typeof2 = require('babel-runtime/helpers/typeof');\n\nvar _typeof3 = _interopRequireDefault(_typeof2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = {\n  props: {\n    value: {\n      twoway: true,\n      required: true\n    },\n    options: {\n      type: Array,\n      default: function _default() {\n        return [];\n      }\n    },\n    maxHeight: {\n      type: String,\n      default: '400px'\n    },\n    searchable: {\n      type: Boolean,\n      default: true\n    },\n    multiple: {\n      type: Boolean,\n      default: false\n    },\n    placeholder: {\n      type: String,\n      default: ''\n    },\n    transition: {\n      type: String,\n      default: 'expand'\n    },\n    clearSearchOnSelect: {\n      type: Boolean,\n      default: true\n    }\n  },\n\n  data: function data() {\n    return {\n      search: '',\n      open: false,\n      typeAheadPointer: -1\n    };\n  },\n\n\n  watch: {\n    options: function options() {\n      this.$set('value', this.multiple ? [] : null);\n    },\n    multiple: function multiple(val) {\n      this.$set('value', val ? [] : null);\n    },\n    filteredOptions: function filteredOptions() {\n      this.typeAheadPointer = 0;\n    }\n  },\n\n  methods: {\n    select: function select(option) {\n      if (!this.isOptionSelected(option)) {\n        if (this.multiple) {\n\n          if (!this.value) {\n            this.$set('value', [option]);\n          } else {\n            this.value.push(option);\n          }\n        } else {\n          this.value = option;\n        }\n      } else {\n        if (this.multiple) {\n          this.value.$remove(option);\n        }\n      }\n\n      if (!this.multiple) {\n        this.open = !this.open;\n      }\n\n      if (this.clearSearchOnSelect) {\n        this.search = '';\n      }\n    },\n    toggleDropdown: function toggleDropdown(e) {\n      if (e.target === this.$els.openIndicator || e.target === this.$els.search || e.target === this.$els.toggle || e.target === this.$el) {\n        if (this.open) {\n          this.$els.search.blur(); // dropdown will close on blur\n        } else {\n            this.open = true;\n            this.$els.search.focus();\n          }\n      }\n    },\n    isOptionSelected: function isOptionSelected(option) {\n      if (this.multiple && this.value) {\n        return this.value.indexOf(option) !== -1;\n      }\n\n      return this.value === option;\n    },\n    getOptionValue: function getOptionValue(option) {\n      if ((typeof option === 'undefined' ? 'undefined' : (0, _typeof3.default)(option)) === 'object' && option.value) {\n        return option.value;\n      }\n\n      return option;\n    },\n    getOptionLabel: function getOptionLabel(option) {\n      if ((typeof option === 'undefined' ? 'undefined' : (0, _typeof3.default)(option)) === 'object' && option.label) {\n        return option.label;\n      }\n\n      return option;\n    },\n    typeAheadUp: function typeAheadUp() {\n      if (this.typeAheadPointer > 0) this.typeAheadPointer--;\n    },\n    typeAheadDown: function typeAheadDown() {\n      if (this.typeAheadPointer < this.filteredOptions.length - 1) this.typeAheadPointer++;\n    },\n    typeAheadSelect: function typeAheadSelect() {\n      if (this.filteredOptions[this.typeAheadPointer]) {\n        this.select(this.filteredOptions[this.typeAheadPointer]);\n      }\n\n      if (this.clearSearchOnSelect) {\n        this.search = \"\";\n      }\n    },\n    onEscape: function onEscape() {\n      if (!this.search.length) {\n        this.$els.search.blur();\n      } else {\n        this.$set('search', '');\n      }\n    },\n    maybeDeleteValue: function maybeDeleteValue() {\n      if (!this.$els.search.value.length && this.value) {\n        return this.multiple ? this.value.pop() : this.$set('value', null);\n      }\n    }\n  },\n\n  computed: {\n    cssClasses: function cssClasses() {\n      return {\n        open: this.open,\n        searchable: this.searchable\n      };\n    },\n    searchPlaceholder: function searchPlaceholder() {\n      if (this.isValueEmpty && this.placeholder) {\n        return this.placeholder;\n      }\n    },\n    filteredOptions: function filteredOptions() {\n      return this.$options.filters.filterBy(this.options, this.search);\n    },\n    isValueEmpty: function isValueEmpty() {\n      if (this.value) {\n        return !this.value.length;\n      }\n\n      return true;\n    },\n    valueAsArray: function valueAsArray() {\n      if (this.multiple) {\n        return this.value;\n      } else if (this.value) {\n        return [this.value];\n      }\n\n      return [];\n    }\n  }\n\n};\nif (module.exports.__esModule) module.exports = module.exports.default\n;(typeof module.exports === \"function\"? module.exports.options: module.exports).template = \"\\n<div class=\\\"dropdown\\\" :class=\\\"cssClasses\\\" _v-3d450ab6=\\\"\\\">\\n  <div v-el:toggle=\\\"\\\" @mousedown.prevent=\\\"toggleDropdown\\\" class=\\\"dropdown-toggle clearfix\\\" type=\\\"button\\\" _v-3d450ab6=\\\"\\\">\\n      <span class=\\\"form-control\\\" v-if=\\\"!searchable &amp;&amp; isValueEmpty\\\" _v-3d450ab6=\\\"\\\">\\n        {{ placeholder }}\\n      </span>\\n\\n      <span class=\\\"selected-tag\\\" v-for=\\\"option in valueAsArray\\\" _v-3d450ab6=\\\"\\\">\\n        {{ getOptionLabel(option) }}\\n        <button v-if=\\\"multiple\\\" @click=\\\"select(option)\\\" type=\\\"button\\\" class=\\\"close\\\" _v-3d450ab6=\\\"\\\">\\n          <span aria-hidden=\\\"true\\\" _v-3d450ab6=\\\"\\\">×</span>\\n        </button>\\n      </span>\\n\\n      <input v-el:search=\\\"\\\" v-show=\\\"searchable\\\" v-model=\\\"search\\\" @keydown.delete=\\\"maybeDeleteValue\\\" @keydown.esc=\\\"onEscape\\\" @keydown.up.prevent=\\\"typeAheadUp\\\" @keydown.down.prevent=\\\"typeAheadDown\\\" @keydown.enter.prevent=\\\"typeAheadSelect\\\" @blur=\\\"open = false\\\" @focus=\\\"open = true\\\" type=\\\"search\\\" class=\\\"form-control\\\" :placeholder=\\\"searchPlaceholder\\\" _v-3d450ab6=\\\"\\\">\\n\\n      <i v-el:open-indicator=\\\"\\\" role=\\\"presentation\\\" class=\\\"open-indicator glyphicon-chevron-down glyphicon\\\" _v-3d450ab6=\\\"\\\"></i>\\n  </div>\\n\\n  <ul v-show=\\\"open\\\" v-el:dropdown-menu=\\\"\\\" :transition=\\\"transition\\\" :style=\\\"{ 'max-height': maxHeight }\\\" class=\\\"dropdown-menu animated\\\" _v-3d450ab6=\\\"\\\">\\n    <li v-for=\\\"option in filteredOptions\\\" :class=\\\"{ active: isOptionSelected(option), highlight: $index === typeAheadPointer }\\\" @mouseover=\\\"typeAheadPointer = $index\\\" _v-3d450ab6=\\\"\\\">\\n      <a @mousedown.prevent=\\\"select(option)\\\" _v-3d450ab6=\\\"\\\">\\n        {{ getOptionLabel(option) }}\\n      </a>\\n    </li>\\n    <li transition=\\\"fade\\\" v-if=\\\"!filteredOptions.length\\\" class=\\\"divider\\\" _v-3d450ab6=\\\"\\\"></li>\\n    <li transition=\\\"fade\\\" v-if=\\\"!filteredOptions.length\\\" class=\\\"text-center\\\" _v-3d450ab6=\\\"\\\">Sorry, no matching options.</li>\\n  </ul>\\n</div>\\n\"\nif (module.hot) {(function () {  module.hot.accept()\n  var hotAPI = require(\"vue-hot-reload-api\")\n  hotAPI.install(require(\"vue\"), true)\n  if (!hotAPI.compatible) return\n  var id = \"/Volumes/Documents/Dropbox/htdocs/vue-select/src/components/Select.vue\"\n  module.hot.dispose(function () {\n    require(\"vueify-insert-css\").cache[\"\\n.dropdown[_v-3d450ab6] {\\n  position: relative;\\n}\\n\\n.open .dropdown-toggle[_v-3d450ab6],\\n.open .dropdown-menu[_v-3d450ab6] {\\n  border-color: rgba(60,60,60,.26);\\n}\\n\\n.open-indicator[_v-3d450ab6] {\\n  position: absolute;\\n  top: 10px;\\n  right: 10px;\\n  display: inline-block;\\n  cursor: pointer;\\n  pointer-events: all;\\n  -webkit-transition: all 150ms cubic-bezier(1.000, -0.115, 0.975, 0.855);\\n  transition: all 150ms cubic-bezier(1.000, -0.115, 0.975, 0.855);\\n  -webkit-transition-timing-function: cubic-bezier(1.000, -0.115, 0.975, 0.855);\\n          transition-timing-function: cubic-bezier(1.000, -0.115, 0.975, 0.855);\\n}\\n\\n.open .open-indicator[_v-3d450ab6] {\\n  -webkit-transform: rotate(180deg);\\n          transform: rotate(180deg);\\n}\\n\\n.dropdown-toggle[_v-3d450ab6] {\\n  display: block;\\n  padding: 0;\\n  background: none;\\n  border: 1px solid rgba(60,60,60,.26);\\n  border-radius: 4px;\\n  white-space: normal;\\n}\\n.searchable .dropdown-toggle[_v-3d450ab6] {\\n  cursor: text;\\n}\\n\\n.open .dropdown-toggle[_v-3d450ab6] {\\n  border-bottom: none;\\n  border-bottom-left-radius: 0;\\n  border-bottom-right-radius: 0;\\n}\\n\\n.dropdown-menu[_v-3d450ab6] {\\n  margin: 0;\\n  width: 100%;\\n  overflow-y: scroll;\\n  border-top: none;\\n  border-top-left-radius: 0;\\n  border-top-right-radius: 0;\\n}\\n\\n.selected-tag[_v-3d450ab6] {\\n  color: #333;\\n  background-color: #f0f0f0;\\n  border: 1px solid #ccc;\\n  border-radius: 4px;\\n  height: 26px;\\n  margin: 4px 1px 0px 3px;\\n  padding: 0 0.25em;\\n  float: left;\\n  line-height: 1.7em;\\n}\\n\\n.selected-tag .close[_v-3d450ab6] {\\n  float: none;\\n  margin-right: 0;\\n  font-size: 20px;\\n}\\n\\ninput[type=search][_v-3d450ab6],\\ninput[type=search][_v-3d450ab6]:focus {\\n  display: inline-block;\\n  border: none;\\n  outline: none;\\n  margin: 0;\\n  width: 10em;\\n  max-width: 100%;\\n  background: none;\\n  position: relative;\\n  box-shadow: none;\\n  float: left;\\n  clear: none;\\n}\\n\\ninput[type=search][_v-3d450ab6]:disabled {\\n  cursor: pointer;\\n}\\n\\nli a[_v-3d450ab6] {\\n  cursor: pointer;\\n}\\n\\n.active a[_v-3d450ab6] {\\n  background: rgba(50,50,50,.1);\\n  color: #333;\\n}\\n\\n.highlight a[_v-3d450ab6],\\nli:hover a[_v-3d450ab6] {\\n  background: #f0f0f0;\\n  color: #333;\\n}\\n\"] = false\n    document.head.removeChild(__vueify_style__)\n  })\n  if (!module.hot.data) {\n    hotAPI.createRecord(id, module.exports)\n  } else {\n    hotAPI.update(id, module.exports, (typeof module.exports === \"function\" ? module.exports.options : module.exports).template)\n  }\n})()}","module.exports = [\n              {value: \"AF\", label: \"Afghanistan\"},\n              {value: \"AX\", label: \"Åland Islands\"},\n              {value: \"AL\", label: \"Albania\"},\n              {value: \"DZ\", label: \"Algeria\"},\n              {value: \"AS\", label: \"American Samoa\"},\n              {value: \"AD\", label: \"Andorra\"},\n              {value: \"AO\", label: \"Angola\"},\n              {value: \"AI\", label: \"Anguilla\"},\n              {value: \"AQ\", label: \"Antarctica\"},\n              {value: \"AG\", label: \"Antigua and Barbuda\"},\n              {value: \"AR\", label: \"Argentina\"},\n              {value: \"AM\", label: \"Armenia\"},\n              {value: \"AW\", label: \"Aruba\"},\n              {value: \"AU\", label: \"Australia\"},\n              {value: \"AT\", label: \"Austria\"},\n              {value: \"AZ\", label: \"Azerbaijan\"},\n              {value: \"BS\", label: \"Bahamas\"},\n              {value: \"BH\", label: \"Bahrain\"},\n              {value: \"BD\", label: \"Bangladesh\"},\n              {value: \"BB\", label: \"Barbados\"},\n              {value: \"BY\", label: \"Belarus\"},\n              {value: \"BE\", label: \"Belgium\"},\n              {value: \"BZ\", label: \"Belize\"},\n              {value: \"BJ\", label: \"Benin\"},\n              {value: \"BM\", label: \"Bermuda\"},\n              {value: \"BT\", label: \"Bhutan\"},\n              {value: \"BO\", label: \"Bolivia\"},\n              {value: \"BA\", label: \"Bosnia and Herzegovina\"},\n              {value: \"BW\", label: \"Botswana\"},\n              {value: \"BV\", label: \"Bouvet Island\"},\n              {value: \"BR\", label: \"Brazil\"},\n              {value: \"IO\", label: \"British Indian Ocean Territory\"},\n              {value: \"BN\", label: \"Brunei Darussalam\"},\n              {value: \"BG\", label: \"Bulgaria\"},\n              {value: \"BF\", label: \"Burkina Faso\"},\n              {value: \"BI\", label: \"Burundi\"},\n              {value: \"KH\", label: \"Cambodia\"},\n              {value: \"CM\", label: \"Cameroon\"},\n              {value: \"CA\", label: \"Canada\"},\n              {value: \"CV\", label: \"Cape Verde\"},\n              {value: \"KY\", label: \"Cayman Islands\"},\n              {value: \"CF\", label: \"Central African Republic\"},\n              {value: \"TD\", label: \"Chad\"},\n              {value: \"CL\", label: \"Chile\"},\n              {value: \"CN\", label: \"China\"},\n              {value: \"CX\", label: \"Christmas Island\"},\n              {value: \"CC\", label: \"Cocos (Keeling) Islands\"},\n              {value: \"CO\", label: \"Colombia\"},\n              {value: \"KM\", label: \"Comoros\"},\n              {value: \"CG\", label: \"Congo\"},\n              {value: \"CD\", label: \"Congo, The Democratic Republic of The\"},\n              {value: \"CK\", label: \"Cook Islands\"},\n              {value: \"CR\", label: \"Costa Rica\"},\n              {value: \"CI\", label: \"Cote D'ivoire\"},\n              {value: \"HR\", label: \"Croatia\"},\n              {value: \"CU\", label: \"Cuba\"},\n              {value: \"CY\", label: \"Cyprus\"},\n              {value: \"CZ\", label: \"Czech Republic\"},\n              {value: \"DK\", label: \"Denmark\"},\n              {value: \"DJ\", label: \"Djibouti\"},\n              {value: \"DM\", label: \"Dominica\"},\n              {value: \"DO\", label: \"Dominican Republic\"},\n              {value: \"EC\", label: \"Ecuador\"},\n              {value: \"EG\", label: \"Egypt\"},\n              {value: \"SV\", label: \"El Salvador\"},\n              {value: \"GQ\", label: \"Equatorial Guinea\"},\n              {value: \"ER\", label: \"Eritrea\"},\n              {value: \"EE\", label: \"Estonia\"},\n              {value: \"ET\", label: \"Ethiopia\"},\n              {value: \"FK\", label: \"Falkland Islands (Malvinas)\"},\n              {value: \"FO\", label: \"Faroe Islands\"},\n              {value: \"FJ\", label: \"Fiji\"},\n              {value: \"FI\", label: \"Finland\"},\n              {value: \"FR\", label: \"France\"},\n              {value: \"GF\", label: \"French Guiana\"},\n              {value: \"PF\", label: \"French Polynesia\"},\n              {value: \"TF\", label: \"French Southern Territories\"},\n              {value: \"GA\", label: \"Gabon\"},\n              {value: \"GM\", label: \"Gambia\"},\n              {value: \"GE\", label: \"Georgia\"},\n              {value: \"DE\", label: \"Germany\"},\n              {value: \"GH\", label: \"Ghana\"},\n              {value: \"GI\", label: \"Gibraltar\"},\n              {value: \"GR\", label: \"Greece\"},\n              {value: \"GL\", label: \"Greenland\"},\n              {value: \"GD\", label: \"Grenada\"},\n              {value: \"GP\", label: \"Guadeloupe\"},\n              {value: \"GU\", label: \"Guam\"},\n              {value: \"GT\", label: \"Guatemala\"},\n              {value: \"GG\", label: \"Guernsey\"},\n              {value: \"GN\", label: \"Guinea\"},\n              {value: \"GW\", label: \"Guinea-bissau\"},\n              {value: \"GY\", label: \"Guyana\"},\n              {value: \"HT\", label: \"Haiti\"},\n              {value: \"HM\", label: \"Heard Island and Mcdonald Islands\"},\n              {value: \"VA\", label: \"Holy See (Vatican City State)\"},\n              {value: \"HN\", label: \"Honduras\"},\n              {value: \"HK\", label: \"Hong Kong\"},\n              {value: \"HU\", label: \"Hungary\"},\n              {value: \"IS\", label: \"Iceland\"},\n              {value: \"IN\", label: \"India\"},\n              {value: \"ID\", label: \"Indonesia\"},\n              {value: \"IR\", label: \"Iran, Islamic Republic of\"},\n              {value: \"IQ\", label: \"Iraq\"},\n              {value: \"IE\", label: \"Ireland\"},\n              {value: \"IM\", label: \"Isle of Man\"},\n              {value: \"IL\", label: \"Israel\"},\n              {value: \"IT\", label: \"Italy\"},\n              {value: \"JM\", label: \"Jamaica\"},\n              {value: \"JP\", label: \"Japan\"},\n              {value: \"JE\", label: \"Jersey\"},\n              {value: \"JO\", label: \"Jordan\"},\n              {value: \"KZ\", label: \"Kazakhstan\"},\n              {value: \"KE\", label: \"Kenya\"},\n              {value: \"KI\", label: \"Kiribati\"},\n              {value: \"KP\", label: \"Korea, Democratic People's Republic of\"},\n              {value: \"KR\", label: \"Korea, Republic of\"},\n              {value: \"KW\", label: \"Kuwait\"},\n              {value: \"KG\", label: \"Kyrgyzstan\"},\n              {value: \"LA\", label: \"Lao People's Democratic Republic\"},\n              {value: \"LV\", label: \"Latvia\"},\n              {value: \"LB\", label: \"Lebanon\"},\n              {value: \"LS\", label: \"Lesotho\"},\n              {value: \"LR\", label: \"Liberia\"},\n              {value: \"LY\", label: \"Libyan Arab Jamahiriya\"},\n              {value: \"LI\", label: \"Liechtenstein\"},\n              {value: \"LT\", label: \"Lithuania\"},\n              {value: \"LU\", label: \"Luxembourg\"},\n              {value: \"MO\", label: \"Macao\"},\n              {value: \"MK\", label: \"Macedonia, The Former Yugoslav Republic of\"},\n              {value: \"MG\", label: \"Madagascar\"},\n              {value: \"MW\", label: \"Malawi\"},\n              {value: \"MY\", label: \"Malaysia\"},\n              {value: \"MV\", label: \"Maldives\"},\n              {value: \"ML\", label: \"Mali\"},\n              {value: \"MT\", label: \"Malta\"},\n              {value: \"MH\", label: \"Marshall Islands\"},\n              {value: \"MQ\", label: \"Martinique\"},\n              {value: \"MR\", label: \"Mauritania\"},\n              {value: \"MU\", label: \"Mauritius\"},\n              {value: \"YT\", label: \"Mayotte\"},\n              {value: \"MX\", label: \"Mexico\"},\n              {value: \"FM\", label: \"Micronesia, Federated States of\"},\n              {value: \"MD\", label: \"Moldova, Republic of\"},\n              {value: \"MC\", label: \"Monaco\"},\n              {value: \"MN\", label: \"Mongolia\"},\n              {value: \"ME\", label: \"Montenegro\"},\n              {value: \"MS\", label: \"Montserrat\"},\n              {value: \"MA\", label: \"Morocco\"},\n              {value: \"MZ\", label: \"Mozambique\"},\n              {value: \"MM\", label: \"Myanmar\"},\n              {value: \"NA\", label: \"Namibia\"},\n              {value: \"NR\", label: \"Nauru\"},\n              {value: \"NP\", label: \"Nepal\"},\n              {value: \"NL\", label: \"Netherlands\"},\n              {value: \"AN\", label: \"Netherlands Antilles\"},\n              {value: \"NC\", label: \"New Caledonia\"},\n              {value: \"NZ\", label: \"New Zealand\"},\n              {value: \"NI\", label: \"Nicaragua\"},\n              {value: \"NE\", label: \"Niger\"},\n              {value: \"NG\", label: \"Nigeria\"},\n              {value: \"NU\", label: \"Niue\"},\n              {value: \"NF\", label: \"Norfolk Island\"},\n              {value: \"MP\", label: \"Northern Mariana Islands\"},\n              {value: \"NO\", label: \"Norway\"},\n              {value: \"OM\", label: \"Oman\"},\n              {value: \"PK\", label: \"Pakistan\"},\n              {value: \"PW\", label: \"Palau\"},\n              {value: \"PS\", label: \"Palestinian Territory, Occupied\"},\n              {value: \"PA\", label: \"Panama\"},\n              {value: \"PG\", label: \"Papua New Guinea\"},\n              {value: \"PY\", label: \"Paraguay\"},\n              {value: \"PE\", label: \"Peru\"},\n              {value: \"PH\", label: \"Philippines\"},\n              {value: \"PN\", label: \"Pitcairn\"},\n              {value: \"PL\", label: \"Poland\"},\n              {value: \"PT\", label: \"Portugal\"},\n              {value: \"PR\", label: \"Puerto Rico\"},\n              {value: \"QA\", label: \"Qatar\"},\n              {value: \"RE\", label: \"Reunion\"},\n              {value: \"RO\", label: \"Romania\"},\n              {value: \"RU\", label: \"Russian Federation\"},\n              {value: \"RW\", label: \"Rwanda\"},\n              {value: \"SH\", label: \"Saint Helena\"},\n              {value: \"KN\", label: \"Saint Kitts and Nevis\"},\n              {value: \"LC\", label: \"Saint Lucia\"},\n              {value: \"PM\", label: \"Saint Pierre and Miquelon\"},\n              {value: \"VC\", label: \"Saint Vincent and The Grenadines\"},\n              {value: \"WS\", label: \"Samoa\"},\n              {value: \"SM\", label: \"San Marino\"},\n              {value: \"ST\", label: \"Sao Tome and Principe\"},\n              {value: \"SA\", label: \"Saudi Arabia\"},\n              {value: \"SN\", label: \"Senegal\"},\n              {value: \"RS\", label: \"Serbia\"},\n              {value: \"SC\", label: \"Seychelles\"},\n              {value: \"SL\", label: \"Sierra Leone\"},\n              {value: \"SG\", label: \"Singapore\"},\n              {value: \"SK\", label: \"Slovakia\"},\n              {value: \"SI\", label: \"Slovenia\"},\n              {value: \"SB\", label: \"Solomon Islands\"},\n              {value: \"SO\", label: \"Somalia\"},\n              {value: \"ZA\", label: \"South Africa\"},\n              {value: \"GS\", label: \"South Georgia and The South Sandwich Islands\"},\n              {value: \"ES\", label: \"Spain\"},\n              {value: \"LK\", label: \"Sri Lanka\"},\n              {value: \"SD\", label: \"Sudan\"},\n              {value: \"SR\", label: \"Suriname\"},\n              {value: \"SJ\", label: \"Svalbard and Jan Mayen\"},\n              {value: \"SZ\", label: \"Swaziland\"},\n              {value: \"SE\", label: \"Sweden\"},\n              {value: \"CH\", label: \"Switzerland\"},\n              {value: \"SY\", label: \"Syrian Arab Republic\"},\n              {value: \"TW\", label: \"Taiwan, Province of China\"},\n              {value: \"TJ\", label: \"Tajikistan\"},\n              {value: \"TZ\", label: \"Tanzania, United Republic of\"},\n              {value: \"TH\", label: \"Thailand\"},\n              {value: \"TL\", label: \"Timor-leste\"},\n              {value: \"TG\", label: \"Togo\"},\n              {value: \"TK\", label: \"Tokelau\"},\n              {value: \"TO\", label: \"Tonga\"},\n              {value: \"TT\", label: \"Trinidad and Tobago\"},\n              {value: \"TN\", label: \"Tunisia\"},\n              {value: \"TR\", label: \"Turkey\"},\n              {value: \"TM\", label: \"Turkmenistan\"},\n              {value: \"TC\", label: \"Turks and Caicos Islands\"},\n              {value: \"TV\", label: \"Tuvalu\"},\n              {value: \"UG\", label: \"Uganda\"},\n              {value: \"UA\", label: \"Ukraine\"},\n              {value: \"AE\", label: \"United Arab Emirates\"},\n              {value: \"GB\", label: \"United Kingdom\"},\n              {value: \"US\", label: \"United States\"},\n              {value: \"UM\", label: \"United States Minor Outlying Islands\"},\n              {value: \"UY\", label: \"Uruguay\"},\n              {value: \"UZ\", label: \"Uzbekistan\"},\n              {value: \"VU\", label: \"Vanuatu\"},\n              {value: \"VE\", label: \"Venezuela\"},\n              {value: \"VN\", label: \"Viet Nam\"},\n              {value: \"VG\", label: \"Virgin Islands, British\"},\n              {value: \"VI\", label: \"Virgin Islands, U.S.\"},\n              {value: \"WF\", label: \"Wallis and Futuna\"},\n              {value: \"EH\", label: \"Western Sahara\"},\n              {value: \"YE\", label: \"Yemen\"},\n              {value: \"ZM\", label: \"Zambia\"},\n              {value: \"ZW\", label: \"Zimbabwe\"},\n          ];\n","module.exports = [\"Afghanistan\",\"Åland Islands\",\"Albania\",\"Algeria\",\"American Samoa\",\"Andorra\",\"Angola\",\"Anguilla\",\"Antarctica\",\"Antigua and Barbuda\",\"Argentina\",\"Armenia\",\"Aruba\",\"Australia\",\"Austria\",\"Azerbaijan\",\"Bahamas\",\"Bahrain\",\"Bangladesh\",\"Barbados\",\"Belarus\",\"Belgium\",\"Belize\",\"Benin\",\"Bermuda\",\"Bhutan\",\"Bolivia\",\"Bosnia and Herzegovina\",\"Botswana\",\"Bouvet Island\",\"Brazil\",\"British Indian Ocean Territory\",\"Brunei Darussalam\",\"Bulgaria\",\"Burkina Faso\",\"Burundi\",\"Cambodia\",\"Cameroon\",\"Canada\",\"Cape Verde\",\"Cayman Islands\",\"Central African Republic\",\"Chad\",\"Chile\",\"China\",\"Christmas Island\",\"Cocos (Keeling) Islands\",\"Colombia\",\"Comoros\",\"Congo\",\"Congo, The Democratic Republic of The\",\"Cook Islands\",\"Costa Rica\",\"Cote D'ivoire\",\"Croatia\",\"Cuba\",\"Cyprus\",\"Czech Republic\",\"Denmark\",\"Djibouti\",\"Dominica\",\"Dominican Republic\",\"Ecuador\",\"Egypt\",\"El Salvador\",\"Equatorial Guinea\",\"Eritrea\",\"Estonia\",\"Ethiopia\",\"Falkland Islands (Malvinas)\",\"Faroe Islands\",\"Fiji\",\"Finland\",\"France\",\"French Guiana\",\"French Polynesia\",\"French Southern Territories\",\"Gabon\",\"Gambia\",\"Georgia\",\"Germany\",\"Ghana\",\"Gibraltar\",\"Greece\",\"Greenland\",\"Grenada\",\"Guadeloupe\",\"Guam\",\"Guatemala\",\"Guernsey\",\"Guinea\",\"Guinea-bissau\",\"Guyana\",\"Haiti\",\"Heard Island and Mcdonald Islands\",\"Holy See (Vatican City State)\",\"Honduras\",\"Hong Kong\",\"Hungary\",\"Iceland\",\"India\",\"Indonesia\",\"Iran, Islamic Republic of\",\"Iraq\",\"Ireland\",\"Isle of Man\",\"Israel\",\"Italy\",\"Jamaica\",\"Japan\",\"Jersey\",\"Jordan\",\"Kazakhstan\",\"Kenya\",\"Kiribati\",\"Korea, Democratic People's Republic of\",\"Korea, Republic of\",\"Kuwait\",\"Kyrgyzstan\",\"Lao People's Democratic Republic\",\"Latvia\",\"Lebanon\",\"Lesotho\",\"Liberia\",\"Libyan Arab Jamahiriya\",\"Liechtenstein\",\"Lithuania\",\"Luxembourg\",\"Macao\",\"Macedonia, The Former Yugoslav Republic of\",\"Madagascar\",\"Malawi\",\"Malaysia\",\"Maldives\",\"Mali\",\"Malta\",\"Marshall Islands\",\"Martinique\",\"Mauritania\",\"Mauritius\",\"Mayotte\",\"Mexico\",\"Micronesia, Federated States of\",\"Moldova, Republic of\",\"Monaco\",\"Mongolia\",\"Montenegro\",\"Montserrat\",\"Morocco\",\"Mozambique\",\"Myanmar\",\"Namibia\",\"Nauru\",\"Nepal\",\"Netherlands\",\"Netherlands Antilles\",\"New Caledonia\",\"New Zealand\",\"Nicaragua\",\"Niger\",\"Nigeria\",\"Niue\",\"Norfolk Island\",\"Northern Mariana Islands\",\"Norway\",\"Oman\",\"Pakistan\",\"Palau\",\"Palestinian Territory, Occupied\",\"Panama\",\"Papua New Guinea\",\"Paraguay\",\"Peru\",\"Philippines\",\"Pitcairn\",\"Poland\",\"Portugal\",\"Puerto Rico\",\"Qatar\",\"Reunion\",\"Romania\",\"Russian Federation\",\"Rwanda\",\"Saint Helena\",\"Saint Kitts and Nevis\",\"Saint Lucia\",\"Saint Pierre and Miquelon\",\"Saint Vincent and The Grenadines\",\"Samoa\",\"San Marino\",\"Sao Tome and Principe\",\"Saudi Arabia\",\"Senegal\",\"Serbia\",\"Seychelles\",\"Sierra Leone\",\"Singapore\",\"Slovakia\",\"Slovenia\",\"Solomon Islands\",\"Somalia\",\"South Africa\",\"South Georgia and The South Sandwich Islands\",\"Spain\",\"Sri Lanka\",\"Sudan\",\"Suriname\",\"Svalbard and Jan Mayen\",\"Swaziland\",\"Sweden\",\"Switzerland\",\"Syrian Arab Republic\",\"Taiwan, Province of China\",\"Tajikistan\",\"Tanzania, United Republic of\",\"Thailand\",\"Timor-leste\",\"Togo\",\"Tokelau\",\"Tonga\",\"Trinidad and Tobago\",\"Tunisia\",\"Turkey\",\"Turkmenistan\",\"Turks and Caicos Islands\",\"Tuvalu\",\"Uganda\",\"Ukraine\",\"United Arab Emirates\",\"United Kingdom\",\"United States\",\"United States Minor Outlying Islands\",\"Uruguay\",\"Uzbekistan\",\"Vanuatu\",\"Venezuela\",\"Viet Nam\",\"Virgin Islands, British\",\"Virgin Islands, U.S.\",\"Wallis and Futuna\",\"Western Sahara\",\"Yemen\",\"Zambia\",\"Zimbabwe\"];\n","import Vue from 'vue'\nimport App from './App.vue'\nimport store from './vuex/store'\n\n/* eslint-disable no-new */\nnew Vue({\n  el: 'body',\n  store,\n  components: { App }\n})\n","import Vue from 'vue'\nimport Vuex from 'vuex'\n\nVue.use(Vuex)\nVue.config.debug = true\n\nconst state = {\n  count: 0\n}\n\nconst mutations = {\n  INCREMENT (state) {\n    state.count++\n  },\n  DECREMENT (state) {\n    state.count--\n  }\n}\n\nexport default new Vuex.Store({\n  state,\n  mutations\n})\n","(function(global, _main, moduleDefs, cachedModules, _entries) {\n  'use strict';\n\n  var moduleMeta = {\"node_modules/browserify-hmr/lib/has.js\":{\"index\":11,\"hash\":\"Hky4QYVrU1+kFHIEuxPy\",\"parents\":[\"node_modules/browserify-hmr/lib/str-set.js\",\"node_modules/browserify-hmr/inc/index.js\"]},\"node_modules/process/browser.js\":{\"index\":137,\"hash\":\"d/Dio43QDX3Xt7NYvbr6\",\"parents\":[\"node_modules/vue/dist/vue.common.js\"]},\"node_modules/vue/dist/vue.common.js\":{\"index\":151,\"hash\":\"1Vqz8fxmKHSuo/7YEUpo\",\"parents\":[\"src/components/Select.vue\",\"src/components/Jumbotron.vue\",\"src/App.vue\",\"src/vuex/store.js\",\"src/main.js\"]},\"node_modules/parseuri/index.js\":{\"index\":136,\"hash\":\"c/c7XftSI6ClFc9h2jOh\",\"parents\":[\"node_modules/socket.io-client/lib/url.js\",\"node_modules/engine.io-client/lib/socket.js\"]},\"node_modules/socket.io-client/lib/url.js\":{\"index\":142,\"hash\":\"eA2ffpU7mjSLlYTvz6k0\",\"parents\":[\"node_modules/socket.io-client/lib/index.js\"]},\"node_modules/debug/browser.js\":{\"index\":46,\"hash\":\"S76q28f1VPJIcCtJn1eq\",\"parents\":[\"node_modules/socket.io-client/lib/url.js\",\"node_modules/socket.io-client/lib/socket.js\",\"node_modules/socket.io-parser/index.js\",\"node_modules/engine.io-client/lib/transports/websocket.js\",\"node_modules/engine.io-client/lib/transports/polling.js\",\"node_modules/engine.io-client/lib/transports/polling-xhr.js\",\"node_modules/engine.io-client/lib/socket.js\",\"node_modules/socket.io-client/lib/manager.js\",\"node_modules/socket.io-client/lib/index.js\"]},\"node_modules/socket.io-client/lib/on.js\":{\"index\":140,\"hash\":\"y5MOoFpTKKBHwE8q8jae\",\"parents\":[\"node_modules/socket.io-client/lib/socket.js\",\"node_modules/socket.io-client/lib/manager.js\"]},\"node_modules/socket.io-client/node_modules/component-emitter/index.js\":{\"index\":143,\"hash\":\"asxNeKKEYmnxnAxICTS6\",\"parents\":[\"node_modules/socket.io-client/lib/socket.js\",\"node_modules/socket.io-client/lib/manager.js\"]},\"node_modules/component-bind/index.js\":{\"index\":13,\"hash\":\"4yIcVw+afwUsnTQyI0a3\",\"parents\":[\"node_modules/socket.io-client/lib/socket.js\",\"node_modules/socket.io-client/lib/manager.js\"]},\"node_modules/to-array/index.js\":{\"index\":148,\"hash\":\"2EoggafxX+GLXkXiaGjm\",\"parents\":[\"node_modules/socket.io-client/lib/socket.js\"]},\"node_modules/socket.io-parser/is-buffer.js\":{\"index\":146,\"hash\":\"F42/EWSzWcL1IvKh+yw4\",\"parents\":[\"node_modules/socket.io-parser/binary.js\",\"node_modules/socket.io-parser/index.js\"]},\"node_modules/isarray/index.js\":{\"index\":64,\"hash\":\"dKtews1S4sHvaZhZ+ceq\",\"parents\":[\"node_modules/has-binary/index.js\",\"node_modules/socket.io-parser/binary.js\",\"node_modules/socket.io-parser/index.js\",\"node_modules/engine.io-parser/node_modules/has-binary/index.js\"]},\"node_modules/component-emitter/index.js\":{\"index\":14,\"hash\":\"0uL1LSa/mOj+Llu+HTZ7\",\"parents\":[\"node_modules/socket.io-parser/index.js\",\"node_modules/engine.io-client/lib/transport.js\",\"node_modules/engine.io-client/lib/transports/polling-xhr.js\",\"node_modules/engine.io-client/lib/socket.js\"]},\"node_modules/socket.io-parser/node_modules/json3/lib/json3.js\":{\"index\":147,\"hash\":\"nN5GuS/Ch9onUpX4WT08\",\"parents\":[\"node_modules/socket.io-parser/index.js\"]},\"node_modules/backo2/index.js\":{\"index\":6,\"hash\":\"L5ry3mfVEw1wgmx9Sa+q\",\"parents\":[\"node_modules/socket.io-client/lib/manager.js\"]},\"node_modules/indexof/index.js\":{\"index\":63,\"hash\":\"8zMGV0j0ID5bUIeT7r+M\",\"parents\":[\"node_modules/engine.io-client/lib/socket.js\",\"node_modules/socket.io-client/lib/manager.js\"]},\"node_modules/browserify-hmr/lib/str-set.js\":{\"index\":12,\"hash\":\"lcrDmQK4uaqOqN+FV4/9\",\"parents\":[\"node_modules/browserify-hmr/inc/index.js\"]},\"node_modules/lodash/internal/arrayFilter.js\":{\"index\":73,\"hash\":\"BGunz0w1QzJXyqQSOdZb\",\"parents\":[\"node_modules/lodash/collection/filter.js\"]},\"node_modules/lodash/internal/arraySome.js\":{\"index\":75,\"hash\":\"GxeJPxJj2jUg5TzV5gLv\",\"parents\":[\"node_modules/lodash/collection/some.js\",\"node_modules/lodash/internal/equalArrays.js\"]},\"node_modules/lodash/internal/arrayEach.js\":{\"index\":72,\"hash\":\"eLxUBVsb8vpFbu0VN4KL\",\"parents\":[\"node_modules/lodash/collection/forEach.js\"]},\"node_modules/lodash/internal/arrayMap.js\":{\"index\":74,\"hash\":\"xdr8c0JsUFapIHTuM5VE\",\"parents\":[\"node_modules/lodash/collection/map.js\"]},\"node_modules/vueify-insert-css/index.js\":{\"index\":152,\"hash\":\"fvTUijA6yyBpp68H+JX2\",\"parents\":[\"src/components/Select.vue\",\"src/App.vue\"]},\"node_modules/vue-hot-reload-api/index.js\":{\"index\":150,\"hash\":\"f1FdC0AX0Gv6zyDU4qOs\",\"parents\":[\"src/components/Select.vue\",\"src/components/Jumbotron.vue\",\"src/App.vue\"]},\"node_modules/ms/index.js\":{\"index\":133,\"hash\":\"HanVKm5AkV6MOdHRAMCT\",\"parents\":[\"node_modules/debug/debug.js\"]},\"node_modules/debug/debug.js\":{\"index\":47,\"hash\":\"yqdR7nJc7wxIHzFDNzG+\",\"parents\":[\"node_modules/debug/browser.js\"]},\"node_modules/has-binary/index.js\":{\"index\":61,\"hash\":\"ghM6s7JwI5VY2IMMbY1o\",\"parents\":[\"node_modules/socket.io-client/lib/socket.js\"]},\"node_modules/socket.io-client/lib/socket.js\":{\"index\":141,\"hash\":\"dZhwrF36uFIGbDZMhss6\",\"parents\":[\"node_modules/socket.io-client/lib/manager.js\",\"node_modules/socket.io-client/lib/index.js\"]},\"node_modules/socket.io-parser/index.js\":{\"index\":145,\"hash\":\"7PrgORY9faIa3QvXeHjU\",\"parents\":[\"node_modules/socket.io-client/lib/socket.js\",\"node_modules/socket.io-client/lib/manager.js\",\"node_modules/socket.io-client/lib/index.js\"]},\"node_modules/socket.io-parser/binary.js\":{\"index\":144,\"hash\":\"8I5NRA1rlGtsqsBVMpry\",\"parents\":[\"node_modules/socket.io-parser/index.js\"]},\"node_modules/lodash/internal/isLength.js\":{\"index\":113,\"hash\":\"DFIKI121VzeE+pBbx1Oa\",\"parents\":[\"node_modules/lodash/internal/createBaseEach.js\",\"node_modules/lodash/internal/isArrayLike.js\",\"node_modules/lodash/lang/isArray.js\",\"node_modules/lodash/object/keysIn.js\",\"node_modules/lodash/internal/shimKeys.js\",\"node_modules/lodash/lang/isTypedArray.js\"]},\"node_modules/lodash/internal/isObjectLike.js\":{\"index\":114,\"hash\":\"qEGnAWJNoAetOIJ7YKiV\",\"parents\":[\"node_modules/lodash/lang/isNative.js\",\"node_modules/lodash/lang/isArray.js\",\"node_modules/lodash/lang/isArguments.js\",\"node_modules/lodash/lang/isTypedArray.js\",\"node_modules/lodash/internal/baseIsEqual.js\"]},\"node_modules/lodash/internal/createObjectMapper.js\":{\"index\":102,\"hash\":\"cp8s+Z6khiKdK5QCQ+Ms\",\"parents\":[\"node_modules/lodash/object/mapValues.js\"]},\"node_modules/lodash/internal/baseCallback.js\":{\"index\":78,\"hash\":\"FDEmxoh1cXY/hddgPNGW\",\"parents\":[\"node_modules/lodash/internal/createObjectMapper.js\",\"node_modules/lodash/collection/map.js\",\"node_modules/lodash/collection/some.js\",\"node_modules/lodash/collection/filter.js\"]},\"node_modules/lodash/internal/baseForOwn.js\":{\"index\":83,\"hash\":\"sOLmHH2OosmeW92YaLK/\",\"parents\":[\"node_modules/lodash/internal/createObjectMapper.js\",\"node_modules/lodash/internal/baseEach.js\",\"node_modules/lodash/object/forOwn.js\"]},\"node_modules/lodash/object/mapValues.js\":{\"index\":129,\"hash\":\"2HfAmVuaVGfc8pd5zIaC\",\"parents\":[\"node_modules/browserify-hmr/inc/index.js\"]},\"node_modules/lodash/utility/identity.js\":{\"index\":131,\"hash\":\"A/cz5O4nnho2x2e5KIWS\",\"parents\":[\"node_modules/lodash/internal/bindCallback.js\",\"node_modules/lodash/internal/baseCallback.js\"]},\"node_modules/lodash/internal/baseFilter.js\":{\"index\":81,\"hash\":\"yyvQag4hw8sItBFf3/9T\",\"parents\":[\"node_modules/lodash/collection/filter.js\"]},\"node_modules/lodash/internal/baseEach.js\":{\"index\":80,\"hash\":\"Ji7NLCJhdzSBlpDI+qC3\",\"parents\":[\"node_modules/lodash/internal/baseFilter.js\",\"node_modules/lodash/internal/baseSome.js\",\"node_modules/lodash/internal/baseMap.js\",\"node_modules/lodash/collection/forEach.js\"]},\"node_modules/lodash/internal/baseSome.js\":{\"index\":94,\"hash\":\"lCW5AtHn9X2vSuPgS8pk\",\"parents\":[\"node_modules/lodash/collection/some.js\"]},\"node_modules/lodash/internal/isIndex.js\":{\"index\":110,\"hash\":\"I8y5AsjL/lwDlORDOqqM\",\"parents\":[\"node_modules/lodash/internal/isIterateeCall.js\",\"node_modules/lodash/object/keysIn.js\",\"node_modules/lodash/internal/shimKeys.js\"]},\"node_modules/lodash/lang/isObject.js\":{\"index\":123,\"hash\":\"Go+dTLFqO1KJN+uQLb8s\",\"parents\":[\"node_modules/lodash/internal/toObject.js\",\"node_modules/lodash/internal/isStrictComparable.js\",\"node_modules/lodash/internal/isIterateeCall.js\",\"node_modules/lodash/lang/isFunction.js\",\"node_modules/lodash/object/keysIn.js\",\"node_modules/lodash/object/keys.js\",\"node_modules/lodash/internal/baseIsEqual.js\"]},\"node_modules/lodash/internal/createForEach.js\":{\"index\":100,\"hash\":\"iJtWBCzx+bzzSLwlaaRv\",\"parents\":[\"node_modules/lodash/collection/forEach.js\"]},\"node_modules/lodash/lang/isArray.js\":{\"index\":120,\"hash\":\"rpMiE1Z199/XZCjno4KN\",\"parents\":[\"node_modules/lodash/internal/createForEach.js\",\"node_modules/lodash/collection/map.js\",\"node_modules/lodash/internal/isKey.js\",\"node_modules/lodash/internal/toPath.js\",\"node_modules/lodash/collection/some.js\",\"node_modules/lodash/array/zipObject.js\",\"node_modules/lodash/object/keysIn.js\",\"node_modules/lodash/internal/shimKeys.js\",\"node_modules/lodash/internal/baseIsEqualDeep.js\",\"node_modules/lodash/internal/baseMatchesProperty.js\",\"node_modules/lodash/collection/filter.js\"]},\"node_modules/lodash/internal/bindCallback.js\":{\"index\":96,\"hash\":\"S6iy1I+53IEzDLSGuW0j\",\"parents\":[\"node_modules/lodash/internal/createForEach.js\",\"node_modules/lodash/internal/createForOwn.js\",\"node_modules/lodash/internal/createAssigner.js\",\"node_modules/lodash/internal/baseCallback.js\"]},\"node_modules/lodash/internal/createForOwn.js\":{\"index\":101,\"hash\":\"KJqijjvJO7d1nU17Sz3c\",\"parents\":[\"node_modules/lodash/object/forOwn.js\"]},\"node_modules/lodash/function/restParam.js\":{\"index\":71,\"hash\":\"/RRH9MCtjArr1p3Qeh63\",\"parents\":[\"node_modules/lodash/internal/createAssigner.js\"]},\"node_modules/lodash/internal/createAssigner.js\":{\"index\":97,\"hash\":\"X8R81jvRCofY1BnG+A/L\",\"parents\":[\"node_modules/lodash/object/assign.js\"]},\"node_modules/lodash/internal/isIterateeCall.js\":{\"index\":111,\"hash\":\"dXMnNRevAizOBisKCEes\",\"parents\":[\"node_modules/lodash/internal/createAssigner.js\",\"node_modules/lodash/collection/some.js\"]},\"node_modules/lodash/internal/assignWith.js\":{\"index\":76,\"hash\":\"aKBKyfIKqZsNOHAbJTAI\",\"parents\":[\"node_modules/lodash/object/assign.js\"]},\"node_modules/lodash/object/keys.js\":{\"index\":127,\"hash\":\"BbXGNIcfatSp32uWOBAV\",\"parents\":[\"node_modules/lodash/internal/assignWith.js\",\"node_modules/lodash/internal/baseAssign.js\",\"node_modules/lodash/object/pairs.js\",\"node_modules/lodash/internal/baseForOwn.js\",\"node_modules/lodash/internal/equalObjects.js\"]},\"node_modules/lodash/internal/baseCopy.js\":{\"index\":79,\"hash\":\"WvGi8IywM6u7ZNXvztwg\",\"parents\":[\"node_modules/lodash/internal/baseAssign.js\"]},\"node_modules/lodash/internal/baseAssign.js\":{\"index\":77,\"hash\":\"6VX87YoeNgDvMUyiAc/7\",\"parents\":[\"node_modules/lodash/object/assign.js\"]},\"node_modules/lodash/object/assign.js\":{\"index\":125,\"hash\":\"9WOhJBREl8AO9Hs6Cr+Q\",\"parents\":[\"node_modules/browserify-hmr/inc/index.js\"]},\"node_modules/lodash/internal/baseMap.js\":{\"index\":88,\"hash\":\"ofv2jCE5QlahpynG4rkN\",\"parents\":[\"node_modules/lodash/collection/map.js\"]},\"node_modules/lodash/internal/isArrayLike.js\":{\"index\":109,\"hash\":\"76Awthz8ChTgjGk0JZ6Y\",\"parents\":[\"node_modules/lodash/internal/baseMap.js\",\"node_modules/lodash/internal/isIterateeCall.js\",\"node_modules/lodash/lang/isArguments.js\",\"node_modules/lodash/object/keys.js\"]},\"node_modules/lodash/collection/map.js\":{\"index\":69,\"hash\":\"63n5x8GTiWPuxiZzm9TM\",\"parents\":[\"node_modules/browserify-hmr/inc/index.js\"]},\"src/countries/simpleCountries.js\":{\"index\":159,\"hash\":\"hLYWkCZR5WGzTBCM7Si4\",\"parents\":[\"src/components/Jumbotron.vue\"]},\"src/countries/countries.js\":{\"index\":158,\"hash\":\"X8uY48ZCe9q8spDOiZgi\",\"parents\":[\"src/components/Jumbotron.vue\"]},\"node_modules/lodash/internal/baseProperty.js\":{\"index\":91,\"hash\":\"Yuk2tpof21q0Xl2sQg89\",\"parents\":[\"node_modules/lodash/utility/property.js\",\"node_modules/lodash/internal/getLength.js\"]},\"node_modules/lodash/internal/baseSlice.js\":{\"index\":93,\"hash\":\"OLgw9XVic1W0AKjehzHB\",\"parents\":[\"node_modules/lodash/internal/baseMatchesProperty.js\"]},\"node_modules/lodash/array/last.js\":{\"index\":65,\"hash\":\"3oXXa2idWbKySVLcq3os\",\"parents\":[\"node_modules/lodash/internal/baseMatchesProperty.js\"]},\"node_modules/lodash/internal/createBaseEach.js\":{\"index\":98,\"hash\":\"+5X3Ztm78NNPr9vQZ7fB\",\"parents\":[\"node_modules/lodash/internal/baseEach.js\"]},\"node_modules/lodash/internal/getLength.js\":{\"index\":106,\"hash\":\"UiZ6F0+nXZ0fiKckTqnM\",\"parents\":[\"node_modules/lodash/internal/createBaseEach.js\",\"node_modules/lodash/internal/isArrayLike.js\"]},\"node_modules/lodash/internal/toObject.js\":{\"index\":117,\"hash\":\"8f3eulB97DddBRdcU+7v\",\"parents\":[\"node_modules/lodash/internal/createBaseEach.js\",\"node_modules/lodash/internal/isKey.js\",\"node_modules/lodash/internal/baseIsMatch.js\",\"node_modules/lodash/internal/baseGet.js\",\"node_modules/lodash/internal/createBaseFor.js\",\"node_modules/lodash/object/pairs.js\",\"node_modules/lodash/internal/baseMatches.js\",\"node_modules/lodash/internal/baseMatchesProperty.js\"]},\"node_modules/lodash/collection/forEach.js\":{\"index\":68,\"hash\":\"0Lo1RNt18PMo/HAKbHEu\",\"parents\":[\"node_modules/browserify-hmr/inc/index.js\"]},\"node_modules/engine.io-parser/lib/keys.js\":{\"index\":59,\"hash\":\"oFyKNTA0twlyQVhVzp9n\",\"parents\":[\"node_modules/engine.io-parser/lib/browser.js\"]},\"node_modules/arraybuffer.slice/index.js\":{\"index\":3,\"hash\":\"RSb5Zx9CgX3adjzbvf/k\",\"parents\":[\"node_modules/engine.io-parser/lib/browser.js\"]},\"node_modules/blob/index.js\":{\"index\":8,\"hash\":\"oJwgFCPr7Au6OHJnm0nr\",\"parents\":[\"node_modules/engine.io-parser/lib/browser.js\"]},\"node_modules/utf8/utf8.js\":{\"index\":149,\"hash\":\"Hbc0UH3rEqjp72mfznNr\",\"parents\":[\"node_modules/engine.io-parser/lib/browser.js\"]},\"node_modules/after/index.js\":{\"index\":2,\"hash\":\"NzPfXWECmM8rW/6fdkcj\",\"parents\":[\"node_modules/engine.io-parser/lib/browser.js\"]},\"node_modules/base64-arraybuffer/lib/base64-arraybuffer.js\":{\"index\":7,\"hash\":\"dW6cnktjBIyZ6bv9vRp2\",\"parents\":[\"node_modules/engine.io-parser/lib/browser.js\"]},\"node_modules/parseqs/index.js\":{\"index\":135,\"hash\":\"FI4tRELwI5Itz+ckwR+m\",\"parents\":[\"node_modules/engine.io-client/lib/transports/websocket.js\",\"node_modules/engine.io-client/lib/transports/polling.js\",\"node_modules/engine.io-client/lib/socket.js\"]},\"node_modules/parsejson/index.js\":{\"index\":134,\"hash\":\"t92555Kfo3kvbKzdtU/P\",\"parents\":[\"node_modules/engine.io-client/lib/socket.js\"]},\"node_modules/lodash/internal/isKey.js\":{\"index\":112,\"hash\":\"lDpw5crcRmTRExTLVTKc\",\"parents\":[\"node_modules/lodash/utility/property.js\",\"node_modules/lodash/internal/baseMatchesProperty.js\"]},\"node_modules/lodash/internal/basePropertyDeep.js\":{\"index\":92,\"hash\":\"mqX1OyYdndJ183lyl/sn\",\"parents\":[\"node_modules/lodash/utility/property.js\"]},\"node_modules/lodash/internal/baseGet.js\":{\"index\":84,\"hash\":\"H9EiMd3ullQpRkvooLgz\",\"parents\":[\"node_modules/lodash/internal/basePropertyDeep.js\",\"node_modules/lodash/internal/baseMatchesProperty.js\"]},\"node_modules/lodash/internal/toPath.js\":{\"index\":118,\"hash\":\"faVQvsb+LSLI4uaMgtrQ\",\"parents\":[\"node_modules/lodash/internal/basePropertyDeep.js\",\"node_modules/lodash/internal/baseMatchesProperty.js\"]},\"node_modules/lodash/utility/property.js\":{\"index\":132,\"hash\":\"7IoOI/uGZCxbcY23uQDK\",\"parents\":[\"node_modules/lodash/internal/baseCallback.js\"]},\"node_modules/lodash/internal/baseIsMatch.js\":{\"index\":87,\"hash\":\"EpuJzlg204aR35T4QKcS\",\"parents\":[\"node_modules/lodash/internal/baseMatches.js\"]},\"node_modules/lodash/internal/baseIsEqual.js\":{\"index\":85,\"hash\":\"dBgoFXnhj9KH6oX3dQwa\",\"parents\":[\"node_modules/lodash/internal/baseIsMatch.js\",\"node_modules/lodash/internal/baseMatchesProperty.js\"]},\"node_modules/lodash/internal/isStrictComparable.js\":{\"index\":115,\"hash\":\"ofNP4/nFrz5Rkb3kGOhn\",\"parents\":[\"node_modules/lodash/internal/getMatchData.js\",\"node_modules/lodash/internal/baseMatchesProperty.js\"]},\"node_modules/lodash/internal/baseToString.js\":{\"index\":95,\"hash\":\"ABFQFf14pRECi3sw8oKV\",\"parents\":[\"node_modules/lodash/internal/toPath.js\"]},\"node_modules/lodash/collection/some.js\":{\"index\":70,\"hash\":\"9JyJFfdCx56pmR6fwM9q\",\"parents\":[\"node_modules/browserify-hmr/inc/index.js\"]},\"node_modules/lodash/internal/createBaseFor.js\":{\"index\":99,\"hash\":\"9RWlFaBOuelvwgkhYgPG\",\"parents\":[\"node_modules/lodash/internal/baseFor.js\"]},\"node_modules/lodash/internal/baseFor.js\":{\"index\":82,\"hash\":\"NGxcZ0n01+w2G1PzyBlY\",\"parents\":[\"node_modules/lodash/internal/baseForOwn.js\"]},\"node_modules/engine.io-parser/node_modules/has-binary/index.js\":{\"index\":60,\"hash\":\"aWcciZgvEP4tdxYE2Lfd\",\"parents\":[\"node_modules/engine.io-parser/lib/browser.js\"]},\"node_modules/engine.io-parser/lib/browser.js\":{\"index\":58,\"hash\":\"X3Q3m2C/zJbJqzepYCjy\",\"parents\":[\"node_modules/engine.io-client/lib/transport.js\",\"node_modules/engine.io-client/lib/transports/websocket.js\",\"node_modules/engine.io-client/lib/transports/polling.js\",\"node_modules/engine.io-client/lib/socket.js\",\"node_modules/engine.io-client/lib/index.js\"]},\"node_modules/engine.io-client/lib/transport.js\":{\"index\":51,\"hash\":\"qAS1jC8gVTG4yb/AanoB\",\"parents\":[\"node_modules/engine.io-client/lib/transports/websocket.js\",\"node_modules/engine.io-client/lib/transports/polling.js\",\"node_modules/engine.io-client/lib/socket.js\"]},\"node_modules/browser-resolve/empty.js\":{\"index\":9,\"hash\":\"47DEQpj8HBSa+/TImW+5\",\"parents\":[\"node_modules/engine.io-client/lib/transports/websocket.js\"]},\"node_modules/lodash/lang/isFunction.js\":{\"index\":121,\"hash\":\"xkfzrZNZPGGOIf0kE8Y9\",\"parents\":[\"node_modules/lodash/lang/isNative.js\"]},\"node_modules/lodash/lang/isNative.js\":{\"index\":122,\"hash\":\"2rstaALy1DW0JSDdijps\",\"parents\":[\"node_modules/lodash/internal/getNative.js\"]},\"node_modules/lodash/internal/getNative.js\":{\"index\":108,\"hash\":\"7GRZ7115BSuoc/1bdaBK\",\"parents\":[\"node_modules/lodash/lang/isArray.js\",\"node_modules/lodash/object/keys.js\"]},\"node_modules/lodash/array/zipObject.js\":{\"index\":66,\"hash\":\"fKfSwIzPo5SUx9d0DkgN\",\"parents\":[\"node_modules/browserify-hmr/inc/index.js\"]},\"node_modules/lodash/object/pairs.js\":{\"index\":130,\"hash\":\"x6Ilwx8encvg/BW5API2\",\"parents\":[\"node_modules/lodash/internal/getMatchData.js\"]},\"node_modules/lodash/internal/getMatchData.js\":{\"index\":107,\"hash\":\"n0PHWhNs6YZ+DzgYMHPx\",\"parents\":[\"node_modules/lodash/internal/baseMatches.js\"]},\"node_modules/lodash/internal/baseMatches.js\":{\"index\":89,\"hash\":\"Cwj5GSiQv9/E8nSFBoX2\",\"parents\":[\"node_modules/lodash/internal/baseCallback.js\"]},\"node_modules/lodash/internal/equalByTag.js\":{\"index\":104,\"hash\":\"+y++gesJpPvyM+2E8aNB\",\"parents\":[\"node_modules/lodash/internal/baseIsEqualDeep.js\"]},\"node_modules/lodash/lang/isArguments.js\":{\"index\":119,\"hash\":\"xQ4mqbsKQMCmtsPbfQc6\",\"parents\":[\"node_modules/lodash/object/keysIn.js\",\"node_modules/lodash/internal/shimKeys.js\"]},\"node_modules/lodash/object/keysIn.js\":{\"index\":128,\"hash\":\"8POZiGR1fRHso579G46Z\",\"parents\":[\"node_modules/lodash/internal/shimKeys.js\"]},\"node_modules/lodash/internal/shimKeys.js\":{\"index\":116,\"hash\":\"oO4aKopmxRfPxyKgRX9F\",\"parents\":[\"node_modules/lodash/object/keys.js\"]},\"node_modules/lodash/object/forOwn.js\":{\"index\":126,\"hash\":\"LZ77PzuJW/wlgVPdvlGc\",\"parents\":[\"node_modules/browserify-hmr/inc/index.js\"]},\"node_modules/has-cors/index.js\":{\"index\":62,\"hash\":\"HwTb4UF/S089ZYA8hrRl\",\"parents\":[\"node_modules/engine.io-client/lib/xmlhttprequest.js\"]},\"node_modules/engine.io-client/lib/xmlhttprequest.js\":{\"index\":57,\"hash\":\"us0FsN5s7hiT3hqVV5lx\",\"parents\":[\"node_modules/engine.io-client/lib/transports/polling.js\",\"node_modules/engine.io-client/lib/transports/polling-xhr.js\",\"node_modules/engine.io-client/lib/transports/index.js\"]},\"node_modules/yeast/index.js\":{\"index\":154,\"hash\":\"ZM3+5w4l/D2f6x7svySF\",\"parents\":[\"node_modules/engine.io-client/lib/transports/websocket.js\",\"node_modules/engine.io-client/lib/transports/polling.js\"]},\"node_modules/component-inherit/index.js\":{\"index\":15,\"hash\":\"T0Fqch4d4akvlr8bh7lc\",\"parents\":[\"node_modules/engine.io-client/lib/transports/websocket.js\",\"node_modules/engine.io-client/lib/transports/polling-jsonp.js\",\"node_modules/engine.io-client/lib/transports/polling.js\",\"node_modules/engine.io-client/lib/transports/polling-xhr.js\"]},\"node_modules/engine.io-client/lib/transports/websocket.js\":{\"index\":56,\"hash\":\"ZRSUX1iAUU5kMC9oN9hc\",\"parents\":[\"node_modules/engine.io-client/lib/transports/index.js\"]},\"node_modules/engine.io-client/lib/transports/polling-jsonp.js\":{\"index\":53,\"hash\":\"cw0j0n9JiZAG/Al34gBk\",\"parents\":[\"node_modules/engine.io-client/lib/transports/index.js\"]},\"node_modules/engine.io-client/lib/transports/polling.js\":{\"index\":55,\"hash\":\"vdgStJPJzZrXTQesqN8z\",\"parents\":[\"node_modules/engine.io-client/lib/transports/polling-jsonp.js\",\"node_modules/engine.io-client/lib/transports/polling-xhr.js\"]},\"node_modules/lodash/internal/equalArrays.js\":{\"index\":103,\"hash\":\"OBJL6vuaOotu5flUeCnv\",\"parents\":[\"node_modules/lodash/internal/baseIsEqualDeep.js\"]},\"node_modules/lodash/internal/equalObjects.js\":{\"index\":105,\"hash\":\"44Iy49kDcaAZsykEdaH3\",\"parents\":[\"node_modules/lodash/internal/baseIsEqualDeep.js\"]},\"node_modules/lodash/lang/isTypedArray.js\":{\"index\":124,\"hash\":\"aVeZyIFGadrEh7EsaDRu\",\"parents\":[\"node_modules/lodash/internal/baseIsEqualDeep.js\"]},\"node_modules/lodash/internal/baseIsEqualDeep.js\":{\"index\":86,\"hash\":\"ltZZaMHmzp6d9jBltV3Y\",\"parents\":[\"node_modules/lodash/internal/baseIsEqual.js\"]},\"node_modules/lodash/internal/baseMatchesProperty.js\":{\"index\":90,\"hash\":\"OudnSoeq2A4ql5lg51kc\",\"parents\":[\"node_modules/lodash/internal/baseCallback.js\"]},\"node_modules/lodash/collection/filter.js\":{\"index\":67,\"hash\":\"XtU5zjCqSDlYcwOLUC13\",\"parents\":[\"node_modules/browserify-hmr/inc/index.js\"]},\"node_modules/browserify-hmr/inc/index.js\":{\"index\":10,\"hash\":\"azyGnExX2uVlPI7oM92b\",\"parents\":[]},\"node_modules/core-js/library/modules/$.core.js\":{\"index\":20,\"hash\":\"jO6z5PVz8f6aTUjm5Hrx\",\"parents\":[\"node_modules/core-js/library/modules/$.export.js\",\"node_modules/core-js/library/fn/symbol/index.js\"]},\"node_modules/core-js/library/modules/es6.object.to-string.js\":{\"index\":44,\"hash\":\"47DEQpj8HBSa+/TImW+5\",\"parents\":[\"node_modules/core-js/library/fn/symbol/index.js\"]},\"node_modules/engine.io-client/lib/transports/polling-xhr.js\":{\"index\":54,\"hash\":\"idg/D5BOlsKB6+2V6pPe\",\"parents\":[\"node_modules/engine.io-client/lib/transports/index.js\"]},\"node_modules/engine.io-client/lib/transports/index.js\":{\"index\":52,\"hash\":\"T2DiP0RY+tM6z+OQNF75\",\"parents\":[\"node_modules/engine.io-client/lib/socket.js\"]},\"node_modules/engine.io-client/lib/socket.js\":{\"index\":50,\"hash\":\"XSGlEwnfJ+YGqRI033+d\",\"parents\":[\"node_modules/engine.io-client/lib/index.js\"]},\"node_modules/engine.io-client/lib/index.js\":{\"index\":49,\"hash\":\"G6QYuSNu0EcS+G5tR9NE\",\"parents\":[\"node_modules/engine.io-client/index.js\"]},\"node_modules/engine.io-client/index.js\":{\"index\":48,\"hash\":\"HQau4MkD4lAynB9tt0Wl\",\"parents\":[\"node_modules/socket.io-client/lib/manager.js\"]},\"node_modules/socket.io-client/lib/manager.js\":{\"index\":139,\"hash\":\"ycazfyz0LQGPtd/P1Ih9\",\"parents\":[\"node_modules/socket.io-client/lib/index.js\"]},\"node_modules/socket.io-client/lib/index.js\":{\"index\":138,\"hash\":\"6O21Z/SJToLoAyfVkS1+\",\"parents\":[]},\"node_modules/core-js/library/modules/$.has.js\":{\"index\":29,\"hash\":\"y4idiH2Sj/rmZqd39CHH\",\"parents\":[\"node_modules/core-js/library/modules/$.set-to-string-tag.js\",\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.js\":{\"index\":34,\"hash\":\"UI1ymRgurU07soRpiobz\",\"parents\":[\"node_modules/core-js/library/modules/$.set-to-string-tag.js\",\"node_modules/core-js/library/modules/$.keyof.js\",\"node_modules/core-js/library/modules/$.enum-keys.js\",\"node_modules/core-js/library/modules/$.get-names.js\",\"node_modules/core-js/library/modules/$.hide.js\",\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.fails.js\":{\"index\":26,\"hash\":\"6G4+YXaRghTGQQnkm/qp\",\"parents\":[\"node_modules/core-js/library/modules/$.descriptors.js\",\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.global.js\":{\"index\":28,\"hash\":\"t7QKkyeVEU+gGSy/l5Cc\",\"parents\":[\"node_modules/core-js/library/modules/$.shared.js\",\"node_modules/core-js/library/modules/$.wks.js\",\"node_modules/core-js/library/modules/$.export.js\",\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.uid.js\":{\"index\":42,\"hash\":\"auy0a5KBxuU7QAdJ7we/\",\"parents\":[\"node_modules/core-js/library/modules/$.wks.js\",\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.property-desc.js\":{\"index\":37,\"hash\":\"iSs9jpAw1JT2ZWWLScSH\",\"parents\":[\"node_modules/core-js/library/modules/$.hide.js\",\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.library.js\":{\"index\":36,\"hash\":\"Bhgn5RpO7pDcQnSVaI5C\",\"parents\":[\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.descriptors.js\":{\"index\":23,\"hash\":\"NJqnAOVs55bKea+gKIGt\",\"parents\":[\"node_modules/core-js/library/modules/$.hide.js\",\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.shared.js\":{\"index\":40,\"hash\":\"ZK+Tn2LANbB4OqkscM3N\",\"parents\":[\"node_modules/core-js/library/modules/$.wks.js\",\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.set-to-string-tag.js\":{\"index\":39,\"hash\":\"3G0pjz42ePfLP++caEH3\",\"parents\":[\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.wks.js\":{\"index\":43,\"hash\":\"qMliszffX6kySHptJTIp\",\"parents\":[\"node_modules/core-js/library/modules/$.set-to-string-tag.js\",\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.keyof.js\":{\"index\":35,\"hash\":\"QAkD89X3k/nEd4vAmyCz\",\"parents\":[\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.to-iobject.js\":{\"index\":41,\"hash\":\"yp4UOuCLRVO1tqlgppw5\",\"parents\":[\"node_modules/core-js/library/modules/$.keyof.js\",\"node_modules/core-js/library/modules/$.get-names.js\",\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.enum-keys.js\":{\"index\":24,\"hash\":\"d/Ib2kcvofwv5M39O14Y\",\"parents\":[\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.get-names.js\":{\"index\":27,\"hash\":\"YHazxvllS2UBE+8VU/uH\",\"parents\":[\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.is-object.js\":{\"index\":33,\"hash\":\"FkaOOMIm0uw4T/qUEXed\",\"parents\":[\"node_modules/core-js/library/modules/$.an-object.js\"]},\"node_modules/core-js/library/modules/$.an-object.js\":{\"index\":18,\"hash\":\"d7pCynXJhKpK2u1S0fph\",\"parents\":[\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.cof.js\":{\"index\":19,\"hash\":\"FY6tg0ymdCS/rEwpAa7R\",\"parents\":[\"node_modules/core-js/library/modules/$.is-array.js\",\"node_modules/core-js/library/modules/$.iobject.js\"]},\"node_modules/core-js/library/modules/$.is-array.js\":{\"index\":32,\"hash\":\"xN9Fwd6YjBUWmVzBxcVm\",\"parents\":[\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.defined.js\":{\"index\":22,\"hash\":\"RZr8uFl+WrrjvGzPSz3c\",\"parents\":[\"node_modules/core-js/library/modules/$.to-iobject.js\"]},\"node_modules/core-js/library/modules/$.iobject.js\":{\"index\":31,\"hash\":\"HvETp5p0zMBjh+wvjxSm\",\"parents\":[\"node_modules/core-js/library/modules/$.to-iobject.js\"]},\"node_modules/core-js/library/modules/$.hide.js\":{\"index\":30,\"hash\":\"2HBwvxEtbt4UpskOWy62\",\"parents\":[\"node_modules/core-js/library/modules/$.redefine.js\"]},\"node_modules/core-js/library/modules/$.redefine.js\":{\"index\":38,\"hash\":\"v4z59Kie6WPVO1h+8oJP\",\"parents\":[\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/$.a-function.js\":{\"index\":17,\"hash\":\"vI7NBVNoKizw/T7ablYt\",\"parents\":[\"node_modules/core-js/library/modules/$.ctx.js\"]},\"node_modules/core-js/library/modules/$.ctx.js\":{\"index\":21,\"hash\":\"IBAqoysxf6uGe4qIslFW\",\"parents\":[\"node_modules/core-js/library/modules/$.export.js\"]},\"node_modules/core-js/library/modules/$.export.js\":{\"index\":25,\"hash\":\"tF6TuwqA3fLdeFKqSI9n\",\"parents\":[\"node_modules/core-js/library/modules/es6.symbol.js\"]},\"node_modules/core-js/library/modules/es6.symbol.js\":{\"index\":45,\"hash\":\"RB3U/3ZSwfWuCvaaW2A4\",\"parents\":[\"node_modules/core-js/library/fn/symbol/index.js\"]},\"node_modules/core-js/library/fn/symbol/index.js\":{\"index\":16,\"hash\":\"2EnyuJY8T+YSjL7XPyTs\",\"parents\":[\"node_modules/babel-runtime/core-js/symbol.js\"]},\"node_modules/babel-runtime/core-js/symbol.js\":{\"index\":4,\"hash\":\"aiWeZ2ndRLi+VSl8A+j6\",\"parents\":[\"node_modules/babel-runtime/helpers/typeof.js\"]},\"node_modules/babel-runtime/helpers/typeof.js\":{\"index\":5,\"hash\":\"EmXNwlygan5mvsdVpEzI\",\"parents\":[\"src/components/Select.vue\"]},\"src/components/Select.vue\":{\"index\":157,\"hash\":\"wlg8anPzo8gxDM6p0Cs7\",\"parents\":[\"src/components/Jumbotron.vue\"]},\"src/components/Jumbotron.vue\":{\"index\":156,\"hash\":\"XTffrFkQCRxXIb0VJWLn\",\"parents\":[\"src/App.vue\"]},\"src/App.vue\":{\"index\":155,\"hash\":\"CamSgByskedxduMbol7z\",\"parents\":[\"src/main.js\"]},\"node_modules/vuex/dist/vuex.js\":{\"index\":153,\"hash\":\"gX//W6yHs/IFY/kkM/lI\",\"parents\":[\"src/vuex/store.js\"]},\"src/vuex/store.js\":{\"index\":161,\"hash\":\"hwHd4AxvLYr1C+NBOgh/\",\"parents\":[\"src/main.js\"]},\"src/main.js\":{\"index\":160,\"hash\":\"z2sdYiItshBNRWvsUwFd\",\"parents\":[]}};\n  var originalEntries = [\"/Volumes/Documents/Dropbox/htdocs/vue-select/src/main.js\"];\n  var updateUrl = null;\n  var updateMode = \"websocket\";\n  var supportModes = [\"none\",\"websocket\"];\n  var ignoreUnaccepted = true;\n  var updateCacheBust = false;\n  var bundleKey = \"websocket:null\";\n  var sioPath = \"./node_modules/socket.io-client/lib/index.js\";\n  var incPath = \"./node_modules/browserify-hmr/inc/index.js\";\n\n  if (!global._hmr) {\n    try {\n      Object.defineProperty(global, '_hmr', {value: {}});\n    } catch(e) {\n      global._hmr = {};\n    }\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(global._hmr, bundleKey)) {\n    // Temporary hack so requiring modules works before the _hmr values are\n    // correctly initialized.\n    global._hmr[bundleKey] = {initModule: function(){}};\n  }\n\n  var main = require(incPath);\n  var isFirstRun = main(\n    moduleDefs, cachedModules, moduleMeta, updateUrl,\n    updateMode, supportModes, ignoreUnaccepted, updateCacheBust, bundleKey,\n    sioPath ? require(sioPath) : null,\n    typeof __filename !== 'undefined' && __filename,\n    typeof __dirname !== 'undefined' && __dirname\n  );\n  if (isFirstRun) {\n    for (var i=0, len=originalEntries.length; i<len; i++) {\n      require(originalEntries[i]);\n    }\n  }\n}).call(\n  this,\n  typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {},\n  arguments[3], arguments[4], arguments[5], arguments[6]\n);\n"]}
|