You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@unomi.apache.org by jk...@apache.org on 2022/07/07 13:28:02 UTC
[unomi] 01/01: UNOMI-626: improve migration system to prepare Unomi 2.0.0 data models migrations
This is an automated email from the ASF dual-hosted git repository.
jkevan pushed a commit to branch improveMigrationSystem
in repository https://gitbox.apache.org/repos/asf/unomi.git
commit c1e07cfd10672710e768d232a51804d8f7c33b26
Author: Kevan <ke...@jahia.com>
AuthorDate: Thu Jul 7 15:27:44 2022 +0200
UNOMI-626: improve migration system to prepare Unomi 2.0.0 data models migrations
---
extensions/web-tracker/javascript/dist/snippet.js | 89 +
.../web-tracker/javascript/dist/snippet.min.js | 2 +
.../web-tracker/javascript/dist/snippet.min.js.map | 1 +
.../web-tracker/javascript/dist/unomi-tracker.js | 16228 +++++++++++++++++++
.../javascript/dist/unomi-tracker.min.js | 27 +
.../javascript/dist/unomi-tracker.min.js.map | 1 +
tools/shell-commands/pom.xml | 12 +
.../unomi/shell/migration/MigrateScript.java | 118 +
.../apache/unomi/shell/migration/Migration.java | 34 +-
.../unomi/shell/migration/actions/Migrate.java | 197 +-
.../unomi/shell/migration/impl/MigrationTo121.java | 22 +-
.../unomi/shell/migration/impl/MigrationTo122.java | 21 +-
.../unomi/shell/migration/impl/MigrationTo150.java | 24 +-
.../unomi/shell/migration/impl/MigrationTo200.java | 52 +-
.../unomi/shell/migration/utils/HttpUtils.java | 5 +-
.../shell/migration/utils/MigrationUtils.java | 44 +
.../migration/migrate-1.2.1-00-migrateTags.groovy | 20 +
.../migrate-1.2.2-00-deleteOldIndexTemplate.groovy | 20 +
.../migrate-1.5.0-00-elasticSearch7.4.groovy | 20 +
...migrate-2.0.0-00-scopesAndProfileAliases.groovy | 20 +
.../migrate-2.0.0-01-segmentReindex.groovy | 21 +
.../resources/OSGI-INF/blueprint/blueprint.xml | 8 -
.../requestBody/2.0.0/base_reindex_request.json | 8 +
.../2.0.0/base_set_index_readonly_request.json | 5 +
.../resources/requestBody/2.0.0/segment_index.json | 64 +
25 files changed, 16857 insertions(+), 206 deletions(-)
diff --git a/extensions/web-tracker/javascript/dist/snippet.js b/extensions/web-tracker/javascript/dist/snippet.js
new file mode 100644
index 000000000..97b0698fe
--- /dev/null
+++ b/extensions/web-tracker/javascript/dist/snippet.js
@@ -0,0 +1,89 @@
+(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+window.unomiTracker || (window.unomiTracker = {});
+(function () {
+ var unomiTracker_queue = [];
+
+ var methods = ['trackSubmit', 'trackClick', 'trackLink', 'trackForm', 'initialize', 'pageview', 'identify', 'reset', 'group', 'track', 'ready', 'alias', 'debug', 'page', 'once', 'off', 'on', 'personalize'];
+
+ var factory = function (method) {
+ return function () {
+ var args = Array.prototype.slice.call(arguments);
+ args.unshift(method);
+ unomiTracker_queue.push(args);
+ return window.unomiTracker;
+ };
+ };
+
+ // For each of our methods, generate a queueing stub.
+ for (var i = 0; i < methods.length; i++) {
+ var method = methods[i];
+ window.unomiTracker[method] = factory(method);
+ }
+
+ function callback(e) {
+ unomiTracker.initialize({
+ 'Apache Unomi': unomiOption
+ });
+
+ // Loop through the interim analytics queue and reapply the calls to their
+ // proper analytics.js method.
+ while (unomiTracker_queue.length > 0) {
+ var item = unomiTracker_queue.shift();
+ var method = item.shift();
+ if (unomiTracker[method]) {
+ unomiTracker[method].apply(unomiTracker, item);
+ }
+ }
+ }
+
+ // Define a method to load Analytics.js from our CDN,
+ // and that will be sure to only ever load it once.
+ unomiTracker.load = function() {
+ // Create an async script element based on your key.
+ var script = document.createElement('script');
+ script.type = 'text/javascript';
+ script.async = true;
+ // TODO we might want to add a check on the url to see if it ends with / or not
+ script.src = unomiOption.url + '/tracker/unomi-tracker.min.js';
+
+ if (script.addEventListener) {
+ script.addEventListener('load', function (e) {
+ if (typeof callback === 'function') {
+ callback(e);
+ }
+ }, false);
+ } else {
+ script.onreadystatechange = function () {
+ if (this.readyState === 'complete' || this.readyState === 'loaded') {
+ callback(window.event);
+ }
+ };
+ }
+
+ // Insert our script next to the first script element.
+ var first = document.getElementsByTagName('script')[0];
+ first.parentNode.insertBefore(script, first);
+ };
+
+ document.addEventListener('DOMContentLoaded', unomiTracker.load);
+
+ unomiTracker.page();
+})();
+
+},{}]},{},[1]);
diff --git a/extensions/web-tracker/javascript/dist/snippet.min.js b/extensions/web-tracker/javascript/dist/snippet.min.js
new file mode 100644
index 000000000..376e4ec4e
--- /dev/null
+++ b/extensions/web-tracker/javascript/dist/snippet.min.js
@@ -0,0 +1,2 @@
+!function t(i,o,a){function c(r,e){if(!o[r]){if(!i[r]){var n="function"==typeof require&&require;if(!e&&n)return n(r,!0);if(u)return u(r,!0);throw(n=new Error("Cannot find module '"+r+"'")).code="MODULE_NOT_FOUND",n}n=o[r]={exports:{}},i[r][0].call(n.exports,function(e){return c(i[r][1][e]||e)},n,n.exports,t,i,o,a)}return o[r].exports}for(var u="function"==typeof require&&require,e=0;e<a.length;e++)c(a[e]);return c}({1:[function(e,r,n){window.unomiTracker||(window.unomiTracker={}),functi [...]
+//# sourceMappingURL=snipper.min.js.map
\ No newline at end of file
diff --git a/extensions/web-tracker/javascript/dist/snippet.min.js.map b/extensions/web-tracker/javascript/dist/snippet.min.js.map
new file mode 100644
index 000000000..2546eac71
--- /dev/null
+++ b/extensions/web-tracker/javascript/dist/snippet.min.js.map
@@ -0,0 +1 @@
+{"version":3,"sources":["snippet.js"],"names":["r","e","n","t","o","i","f","c","require","u","a","Error","code","p","exports","call","length","1","module","window","unomiTracker","unomiTracker_queue","methods","method","args","Array","prototype","slice","arguments","unshift","push","factory","callback","initialize","Apache Unomi","unomiOption","item","shift","apply","load","script","document","createElement","type","async","src","url","addEventListener","onreadystatechange","this","ready [...]
\ No newline at end of file
diff --git a/extensions/web-tracker/javascript/dist/unomi-tracker.js b/extensions/web-tracker/javascript/dist/unomi-tracker.js
new file mode 100644
index 000000000..340cb8e58
--- /dev/null
+++ b/extensions/web-tracker/javascript/dist/unomi-tracker.js
@@ -0,0 +1,16228 @@
+/*!
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @license Apache-2.0
+ */
+
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.unomiTracker = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)ret [...]
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var arity = require('@ndhoule/arity');
+
+var objToString = Object.prototype.toString;
+
+/**
+ * Determine if a value is a function.
+ *
+ * @param {*} val
+ * @return {boolean}
+ */
+// TODO: Move to lib
+var isFunction = function(val) {
+ return typeof val === 'function';
+};
+
+/**
+ * Determine if a value is a number.
+ *
+ * @param {*} val
+ * @return {boolean}
+ */
+// TODO: Move to lib
+var isNumber = function(val) {
+ var type = typeof val;
+ return type === 'number' || (type === 'object' && objToString.call(val) === '[object Number]');
+};
+
+/**
+ * Wrap a function `fn` in a function that will invoke `fn` when invoked `n` or
+ * more times.
+ *
+ * @name after
+ * @api public
+ * @category Function
+ * @param {Number} n The number of
+ * @param {Function} fn The function to wrap.
+ * @return {Function} A function that will call `fn` after `n` or more
+ * invocations.
+ * @example
+ */
+var after = function after(n, fn) {
+ if (!isNumber(n)) {
+ throw new TypeError('Expected a number but received ' + typeof n);
+ }
+
+ if (!isFunction(fn)) {
+ throw new TypeError('Expected a function but received ' + typeof fn);
+ }
+
+ var callCount = 0;
+
+ return arity(fn.length, function() {
+ callCount += 1;
+
+ if (callCount < n) {
+ return;
+ }
+
+ return fn.apply(this, arguments);
+ });
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = after;
+
+},{"@ndhoule/arity":2}],2:[function(require,module,exports){
+'use strict';
+
+var objToString = Object.prototype.toString;
+
+/**
+ * Determine if a value is a function.
+ *
+ * @param {*} val
+ * @return {boolean}
+ */
+// TODO: Move to lib
+var isFunction = function(val) {
+ return typeof val === 'function';
+};
+
+/**
+ * Determine if a value is a number.
+ *
+ * @param {*} val
+ * @return {boolean}
+ */
+// TODO: Move to lib
+var isNumber = function(val) {
+ var type = typeof val;
+ return type === 'number' || (type === 'object' && objToString.call(val) === '[object Number]');
+};
+
+ /**
+ * Creates an array of generic, numbered argument names.
+ *
+ * @name createParams
+ * @api private
+ * @param {number} n
+ * @return {Array}
+ * @example
+ * argNames(2);
+ * //=> ['arg1', 'arg2']
+ */
+var createParams = function createParams(n) {
+ var args = [];
+
+ for (var i = 1; i <= n; i += 1) {
+ args.push('arg' + i);
+ }
+
+ return args;
+};
+
+ /**
+ * Dynamically construct a wrapper function of `n` arity that.
+ *
+ * If at all possible, prefer a function from the arity wrapper cache above to
+ * avoid allocating a new function at runtime.
+ *
+ * @name createArityWrapper
+ * @api private
+ * @param {number} n
+ * @return {Function(Function)}
+ */
+var createArityWrapper = function createArityWrapper(n) {
+ var paramNames = createParams(n).join(', ');
+ var wrapperBody = ''.concat(
+ ' return function(', paramNames, ') {\n',
+ ' return func.apply(this, arguments);\n',
+ ' };'
+ );
+
+ /* eslint-disable no-new-func */
+ return new Function('func', wrapperBody);
+ /* eslint-enable no-new-func */
+};
+
+// Cache common arity wrappers to avoid constructing them at runtime
+var arityWrapperCache = [
+ /* eslint-disable no-unused-vars */
+ function(fn) {
+ return function() {
+ return fn.apply(this, arguments);
+ };
+ },
+
+ function(fn) {
+ return function(arg1) {
+ return fn.apply(this, arguments);
+ };
+ },
+
+ function(fn) {
+ return function(arg1, arg2) {
+ return fn.apply(this, arguments);
+ };
+ },
+
+ function(fn) {
+ return function(arg1, arg2, arg3) {
+ return fn.apply(this, arguments);
+ };
+ },
+
+ function(fn) {
+ return function(arg1, arg2, arg3, arg4) {
+ return fn.apply(this, arguments);
+ };
+ },
+
+ function(fn) {
+ return function(arg1, arg2, arg3, arg4, arg5) {
+ return fn.apply(this, arguments);
+ };
+ }
+ /* eslint-enable no-unused-vars */
+];
+
+/**
+ * Takes a function and an [arity](https://en.wikipedia.org/wiki/Arity) `n`, and returns a new
+ * function that expects `n` arguments.
+ *
+ * @name arity
+ * @api public
+ * @category Function
+ * @see {@link curry}
+ * @param {Number} n The desired arity of the returned function.
+ * @param {Function} fn The function to wrap.
+ * @return {Function} A function of n arity, wrapping `fn`.
+ * @example
+ * var add = function(a, b) {
+ * return a + b;
+ * };
+ *
+ * // Check the number of arguments this function expects by accessing `.length`:
+ * add.length;
+ * //=> 2
+ *
+ * var unaryAdd = arity(1, add);
+ * unaryAdd.length;
+ * //=> 1
+ */
+var arity = function arity(n, func) {
+ if (!isFunction(func)) {
+ throw new TypeError('Expected a function but got ' + typeof func);
+ }
+
+ n = Math.max(isNumber(n) ? n : 0, 0);
+
+ if (!arityWrapperCache[n]) {
+ arityWrapperCache[n] = createArityWrapper(n);
+ }
+
+ return arityWrapperCache[n](func);
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = arity;
+
+},{}],3:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var type = require('component-type');
+
+/**
+ * Deeply clone an object.
+ *
+ * @param {*} obj Any object.
+ */
+
+var clone = function clone(obj) {
+ var t = type(obj);
+
+ if (t === 'object') {
+ var copy = {};
+ for (var key in obj) {
+ if (obj.hasOwnProperty(key)) {
+ copy[key] = clone(obj[key]);
+ }
+ }
+ return copy;
+ }
+
+ if (t === 'array') {
+ var copy = new Array(obj.length);
+ for (var i = 0, l = obj.length; i < l; i++) {
+ copy[i] = clone(obj[i]);
+ }
+ return copy;
+ }
+
+ if (t === 'regexp') {
+ // from millermedeiros/amd-utils - MIT
+ var flags = '';
+ flags += obj.multiline ? 'm' : '';
+ flags += obj.global ? 'g' : '';
+ flags += obj.ignoreCase ? 'i' : '';
+ return new RegExp(obj.source, flags);
+ }
+
+ if (t === 'date') {
+ return new Date(obj.getTime());
+ }
+
+ // string, number, boolean, etc.
+ return obj;
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = clone;
+
+},{"component-type":57}],4:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var drop = require('@ndhoule/drop');
+var rest = require('@ndhoule/rest');
+
+var has = Object.prototype.hasOwnProperty;
+var objToString = Object.prototype.toString;
+
+/**
+ * Returns `true` if a value is an object, otherwise `false`.
+ *
+ * @name isObject
+ * @api private
+ * @param {*} val The value to test.
+ * @return {boolean}
+ */
+// TODO: Move to a library
+var isObject = function isObject(value) {
+ return Boolean(value) && typeof value === 'object';
+};
+
+/**
+ * Returns `true` if a value is a plain object, otherwise `false`.
+ *
+ * @name isPlainObject
+ * @api private
+ * @param {*} val The value to test.
+ * @return {boolean}
+ */
+// TODO: Move to a library
+var isPlainObject = function isPlainObject(value) {
+ return Boolean(value) && objToString.call(value) === '[object Object]';
+};
+
+/**
+ * Assigns a key-value pair to a target object when the value assigned is owned,
+ * and where target[key] is undefined.
+ *
+ * @name shallowCombiner
+ * @api private
+ * @param {Object} target
+ * @param {Object} source
+ * @param {*} value
+ * @param {string} key
+ */
+var shallowCombiner = function shallowCombiner(target, source, value, key) {
+ if (has.call(source, key) && target[key] === undefined) {
+ target[key] = value;
+ }
+ return source;
+};
+
+/**
+ * Assigns a key-value pair to a target object when the value assigned is owned,
+ * and where target[key] is undefined; also merges objects recursively.
+ *
+ * @name deepCombiner
+ * @api private
+ * @param {Object} target
+ * @param {Object} source
+ * @param {*} value
+ * @param {string} key
+ * @return {Object}
+ */
+var deepCombiner = function(target, source, value, key) {
+ if (has.call(source, key)) {
+ if (isPlainObject(target[key]) && isPlainObject(value)) {
+ target[key] = defaultsDeep(target[key], value);
+ } else if (target[key] === undefined) {
+ target[key] = value;
+ }
+ }
+
+ return source;
+};
+
+/**
+ * TODO: Document
+ *
+ * @name defaultsWith
+ * @api private
+ * @param {Function} combiner
+ * @param {Object} target
+ * @param {...Object} sources
+ * @return {Object} Return the input `target`.
+ */
+var defaultsWith = function(combiner, target /*, ...sources */) {
+ if (!isObject(target)) {
+ return target;
+ }
+
+ combiner = combiner || shallowCombiner;
+ var sources = drop(2, arguments);
+
+ for (var i = 0; i < sources.length; i += 1) {
+ for (var key in sources[i]) {
+ combiner(target, sources[i], sources[i][key], key);
+ }
+ }
+
+ return target;
+};
+
+/**
+ * Copies owned, enumerable properties from a source object(s) to a target
+ * object when the value of that property on the source object is `undefined`.
+ * Recurses on objects.
+ *
+ * @name defaultsDeep
+ * @api public
+ * @param {Object} target
+ * @param {...Object} sources
+ * @return {Object} The input `target`.
+ */
+var defaultsDeep = function defaultsDeep(target /*, sources */) {
+ // TODO: Replace with `partial` call?
+ return defaultsWith.apply(null, [deepCombiner, target].concat(rest(arguments)));
+};
+
+/**
+ * Copies owned, enumerable properties from a source object(s) to a target
+ * object when the value of that property on the source object is `undefined`.
+ *
+ * @name defaults
+ * @api public
+ * @param {Object} target
+ * @param {...Object} sources
+ * @return {Object}
+ * @example
+ * var a = { a: 1 };
+ * var b = { a: 2, b: 2 };
+ *
+ * defaults(a, b);
+ * console.log(a); //=> { a: 1, b: 2 }
+ */
+var defaults = function(target /*, ...sources */) {
+ // TODO: Replace with `partial` call?
+ return defaultsWith.apply(null, [null, target].concat(rest(arguments)));
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = defaults;
+module.exports.deep = defaultsDeep;
+
+},{"@ndhoule/drop":5,"@ndhoule/rest":14}],5:[function(require,module,exports){
+'use strict';
+
+var max = Math.max;
+
+/**
+ * Produce a new array composed of all but the first `n` elements of an input `collection`.
+ *
+ * @name drop
+ * @api public
+ * @param {number} count The number of elements to drop.
+ * @param {Array} collection The collection to iterate over.
+ * @return {Array} A new array containing all but the first element from `collection`.
+ * @example
+ * drop(0, [1, 2, 3]); // => [1, 2, 3]
+ * drop(1, [1, 2, 3]); // => [2, 3]
+ * drop(2, [1, 2, 3]); // => [3]
+ * drop(3, [1, 2, 3]); // => []
+ * drop(4, [1, 2, 3]); // => []
+ */
+var drop = function drop(count, collection) {
+ var length = collection ? collection.length : 0;
+
+ if (!length) {
+ return [];
+ }
+
+ // Preallocating an array *significantly* boosts performance when dealing with
+ // `arguments` objects on v8. For a summary, see:
+ // https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments
+ var toDrop = max(Number(count) || 0, 0);
+ var resultsLength = max(length - toDrop, 0);
+ var results = new Array(resultsLength);
+
+ for (var i = 0; i < resultsLength; i += 1) {
+ results[i] = collection[i + toDrop];
+ }
+
+ return results;
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = drop;
+
+},{}],6:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var keys = require('@ndhoule/keys');
+
+var objToString = Object.prototype.toString;
+
+/**
+ * Tests if a value is a number.
+ *
+ * @name isNumber
+ * @api private
+ * @param {*} val The value to test.
+ * @return {boolean} Returns `true` if `val` is a number, otherwise `false`.
+ */
+// TODO: Move to library
+var isNumber = function isNumber(val) {
+ var type = typeof val;
+ return type === 'number' || (type === 'object' && objToString.call(val) === '[object Number]');
+};
+
+/**
+ * Tests if a value is an array.
+ *
+ * @name isArray
+ * @api private
+ * @param {*} val The value to test.
+ * @return {boolean} Returns `true` if the value is an array, otherwise `false`.
+ */
+// TODO: Move to library
+var isArray = typeof Array.isArray === 'function' ? Array.isArray : function isArray(val) {
+ return objToString.call(val) === '[object Array]';
+};
+
+/**
+ * Tests if a value is array-like. Array-like means the value is not a function and has a numeric
+ * `.length` property.
+ *
+ * @name isArrayLike
+ * @api private
+ * @param {*} val
+ * @return {boolean}
+ */
+// TODO: Move to library
+var isArrayLike = function isArrayLike(val) {
+ return val != null && (isArray(val) || (val !== 'function' && isNumber(val.length)));
+};
+
+/**
+ * Internal implementation of `each`. Works on arrays and array-like data structures.
+ *
+ * @name arrayEach
+ * @api private
+ * @param {Function(value, key, collection)} iterator The function to invoke per iteration.
+ * @param {Array} array The array(-like) structure to iterate over.
+ * @return {undefined}
+ */
+var arrayEach = function arrayEach(iterator, array) {
+ for (var i = 0; i < array.length; i += 1) {
+ // Break iteration early if `iterator` returns `false`
+ if (iterator(array[i], i, array) === false) {
+ break;
+ }
+ }
+};
+
+/**
+ * Internal implementation of `each`. Works on objects.
+ *
+ * @name baseEach
+ * @api private
+ * @param {Function(value, key, collection)} iterator The function to invoke per iteration.
+ * @param {Object} object The object to iterate over.
+ * @return {undefined}
+ */
+var baseEach = function baseEach(iterator, object) {
+ var ks = keys(object);
+
+ for (var i = 0; i < ks.length; i += 1) {
+ // Break iteration early if `iterator` returns `false`
+ if (iterator(object[ks[i]], ks[i], object) === false) {
+ break;
+ }
+ }
+};
+
+/**
+ * Iterate over an input collection, invoking an `iterator` function for each element in the
+ * collection and passing to it three arguments: `(value, index, collection)`. The `iterator`
+ * function can end iteration early by returning `false`.
+ *
+ * @name each
+ * @api public
+ * @param {Function(value, key, collection)} iterator The function to invoke per iteration.
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @return {undefined} Because `each` is run only for side effects, always returns `undefined`.
+ * @example
+ * var log = console.log.bind(console);
+ *
+ * each(log, ['a', 'b', 'c']);
+ * //-> 'a', 0, ['a', 'b', 'c']
+ * //-> 'b', 1, ['a', 'b', 'c']
+ * //-> 'c', 2, ['a', 'b', 'c']
+ * //=> undefined
+ *
+ * each(log, 'tim');
+ * //-> 't', 2, 'tim'
+ * //-> 'i', 1, 'tim'
+ * //-> 'm', 0, 'tim'
+ * //=> undefined
+ *
+ * // Note: Iteration order not guaranteed across environments
+ * each(log, { name: 'tim', occupation: 'enchanter' });
+ * //-> 'tim', 'name', { name: 'tim', occupation: 'enchanter' }
+ * //-> 'enchanter', 'occupation', { name: 'tim', occupation: 'enchanter' }
+ * //=> undefined
+ */
+var each = function each(iterator, collection) {
+ return (isArrayLike(collection) ? arrayEach : baseEach).call(this, iterator, collection);
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = each;
+
+},{"@ndhoule/keys":11}],7:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var each = require('@ndhoule/each');
+
+/**
+ * Check if a predicate function returns `true` for all values in a `collection`.
+ * Checks owned, enumerable values and exits early when `predicate` returns
+ * `false`.
+ *
+ * @name every
+ * @param {Function} predicate The function used to test values.
+ * @param {Array|Object|string} collection The collection to search.
+ * @return {boolean} True if all values passes the predicate test, otherwise false.
+ * @example
+ * var isEven = function(num) { return num % 2 === 0; };
+ *
+ * every(isEven, []); // => true
+ * every(isEven, [1, 2]); // => false
+ * every(isEven, [2, 4, 6]); // => true
+ */
+var every = function every(predicate, collection) {
+ if (typeof predicate !== 'function') {
+ throw new TypeError('`predicate` must be a function but was a ' + typeof predicate);
+ }
+
+ var result = true;
+
+ each(function(val, key, collection) {
+ result = !!predicate(val, key, collection);
+
+ // Exit early
+ if (!result) {
+ return false;
+ }
+ }, collection);
+
+ return result;
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = every;
+
+},{"@ndhoule/each":6}],8:[function(require,module,exports){
+'use strict';
+
+var has = Object.prototype.hasOwnProperty;
+
+/**
+ * Copy the properties of one or more `objects` onto a destination object. Input objects are iterated over
+ * in left-to-right order, so duplicate properties on later objects will overwrite those from
+ * erevious ones. Only enumerable and own properties of the input objects are copied onto the
+ * resulting object.
+ *
+ * @name extend
+ * @api public
+ * @category Object
+ * @param {Object} dest The destination object.
+ * @param {...Object} sources The source objects.
+ * @return {Object} `dest`, extended with the properties of all `sources`.
+ * @example
+ * var a = { a: 'a' };
+ * var b = { b: 'b' };
+ * var c = { c: 'c' };
+ *
+ * extend(a, b, c);
+ * //=> { a: 'a', b: 'b', c: 'c' };
+ */
+var extend = function extend(dest /*, sources */) {
+ var sources = Array.prototype.slice.call(arguments, 1);
+
+ for (var i = 0; i < sources.length; i += 1) {
+ for (var key in sources[i]) {
+ if (has.call(sources[i], key)) {
+ dest[key] = sources[i][key];
+ }
+ }
+ }
+
+ return dest;
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = extend;
+
+},{}],9:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var each = require('@ndhoule/each');
+
+/**
+ * Reduces all the values in a collection down into a single value. Does so by iterating through the
+ * collection from left to right, repeatedly calling an `iterator` function and passing to it four
+ * arguments: `(accumulator, value, index, collection)`.
+ *
+ * Returns the final return value of the `iterator` function.
+ *
+ * @name foldl
+ * @api public
+ * @param {Function} iterator The function to invoke per iteration.
+ * @param {*} accumulator The initial accumulator value, passed to the first invocation of `iterator`.
+ * @param {Array|Object} collection The collection to iterate over.
+ * @return {*} The return value of the final call to `iterator`.
+ * @example
+ * foldl(function(total, n) {
+ * return total + n;
+ * }, 0, [1, 2, 3]);
+ * //=> 6
+ *
+ * var phonebook = { bob: '555-111-2345', tim: '655-222-6789', sheila: '655-333-1298' };
+ *
+ * foldl(function(results, phoneNumber) {
+ * if (phoneNumber[0] === '6') {
+ * return results.concat(phoneNumber);
+ * }
+ * return results;
+ * }, [], phonebook);
+ * // => ['655-222-6789', '655-333-1298']
+ */
+var foldl = function foldl(iterator, accumulator, collection) {
+ if (typeof iterator !== 'function') {
+ throw new TypeError('Expected a function but received a ' + typeof iterator);
+ }
+
+ each(function(val, i, collection) {
+ accumulator = iterator(accumulator, val, i, collection);
+ }, collection);
+
+ return accumulator;
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = foldl;
+
+},{"@ndhoule/each":6}],10:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var each = require('@ndhoule/each');
+
+var strIndexOf = String.prototype.indexOf;
+
+/**
+ * Object.is/sameValueZero polyfill.
+ *
+ * @api private
+ * @param {*} value1
+ * @param {*} value2
+ * @return {boolean}
+ */
+// TODO: Move to library
+var sameValueZero = function sameValueZero(value1, value2) {
+ // Normal values and check for 0 / -0
+ if (value1 === value2) {
+ return value1 !== 0 || 1 / value1 === 1 / value2;
+ }
+ // NaN
+ return value1 !== value1 && value2 !== value2;
+};
+
+/**
+ * Searches a given `collection` for a value, returning true if the collection
+ * contains the value and false otherwise. Can search strings, arrays, and
+ * objects.
+ *
+ * @name includes
+ * @api public
+ * @param {*} searchElement The element to search for.
+ * @param {Object|Array|string} collection The collection to search.
+ * @return {boolean}
+ * @example
+ * includes(2, [1, 2, 3]);
+ * //=> true
+ *
+ * includes(4, [1, 2, 3]);
+ * //=> false
+ *
+ * includes(2, { a: 1, b: 2, c: 3 });
+ * //=> true
+ *
+ * includes('a', { a: 1, b: 2, c: 3 });
+ * //=> false
+ *
+ * includes('abc', 'xyzabc opq');
+ * //=> true
+ *
+ * includes('nope', 'xyzabc opq');
+ * //=> false
+ */
+var includes = function includes(searchElement, collection) {
+ var found = false;
+
+ // Delegate to String.prototype.indexOf when `collection` is a string
+ if (typeof collection === 'string') {
+ return strIndexOf.call(collection, searchElement) !== -1;
+ }
+
+ // Iterate through enumerable/own array elements and object properties.
+ each(function(value) {
+ if (sameValueZero(value, searchElement)) {
+ found = true;
+ // Exit iteration early when found
+ return false;
+ }
+ }, collection);
+
+ return found;
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = includes;
+
+},{"@ndhoule/each":6}],11:[function(require,module,exports){
+'use strict';
+
+var hop = Object.prototype.hasOwnProperty;
+var strCharAt = String.prototype.charAt;
+var toStr = Object.prototype.toString;
+
+/**
+ * Returns the character at a given index.
+ *
+ * @param {string} str
+ * @param {number} index
+ * @return {string|undefined}
+ */
+// TODO: Move to a library
+var charAt = function(str, index) {
+ return strCharAt.call(str, index);
+};
+
+/**
+ * hasOwnProperty, wrapped as a function.
+ *
+ * @name has
+ * @api private
+ * @param {*} context
+ * @param {string|number} prop
+ * @return {boolean}
+ */
+
+// TODO: Move to a library
+var has = function has(context, prop) {
+ return hop.call(context, prop);
+};
+
+/**
+ * Returns true if a value is a string, otherwise false.
+ *
+ * @name isString
+ * @api private
+ * @param {*} val
+ * @return {boolean}
+ */
+
+// TODO: Move to a library
+var isString = function isString(val) {
+ return toStr.call(val) === '[object String]';
+};
+
+/**
+ * Returns true if a value is array-like, otherwise false. Array-like means a
+ * value is not null, undefined, or a function, and has a numeric `length`
+ * property.
+ *
+ * @name isArrayLike
+ * @api private
+ * @param {*} val
+ * @return {boolean}
+ */
+// TODO: Move to a library
+var isArrayLike = function isArrayLike(val) {
+ return val != null && (typeof val !== 'function' && typeof val.length === 'number');
+};
+
+
+/**
+ * indexKeys
+ *
+ * @name indexKeys
+ * @api private
+ * @param {} target
+ * @param {Function} pred
+ * @return {Array}
+ */
+var indexKeys = function indexKeys(target, pred) {
+ pred = pred || has;
+
+ var results = [];
+
+ for (var i = 0, len = target.length; i < len; i += 1) {
+ if (pred(target, i)) {
+ results.push(String(i));
+ }
+ }
+
+ return results;
+};
+
+/**
+ * Returns an array of an object's owned keys.
+ *
+ * @name objectKeys
+ * @api private
+ * @param {*} target
+ * @param {Function} pred Predicate function used to include/exclude values from
+ * the resulting array.
+ * @return {Array}
+ */
+var objectKeys = function objectKeys(target, pred) {
+ pred = pred || has;
+
+ var results = [];
+
+ for (var key in target) {
+ if (pred(target, key)) {
+ results.push(String(key));
+ }
+ }
+
+ return results;
+};
+
+/**
+ * Creates an array composed of all keys on the input object. Ignores any non-enumerable properties.
+ * More permissive than the native `Object.keys` function (non-objects will not throw errors).
+ *
+ * @name keys
+ * @api public
+ * @category Object
+ * @param {Object} source The value to retrieve keys from.
+ * @return {Array} An array containing all the input `source`'s keys.
+ * @example
+ * keys({ likes: 'avocado', hates: 'pineapple' });
+ * //=> ['likes', 'pineapple'];
+ *
+ * // Ignores non-enumerable properties
+ * var hasHiddenKey = { name: 'Tim' };
+ * Object.defineProperty(hasHiddenKey, 'hidden', {
+ * value: 'i am not enumerable!',
+ * enumerable: false
+ * })
+ * keys(hasHiddenKey);
+ * //=> ['name'];
+ *
+ * // Works on arrays
+ * keys(['a', 'b', 'c']);
+ * //=> ['0', '1', '2']
+ *
+ * // Skips unpopulated indices in sparse arrays
+ * var arr = [1];
+ * arr[4] = 4;
+ * keys(arr);
+ * //=> ['0', '4']
+ */
+var keys = function keys(source) {
+ if (source == null) {
+ return [];
+ }
+
+ // IE6-8 compatibility (string)
+ if (isString(source)) {
+ return indexKeys(source, charAt);
+ }
+
+ // IE6-8 compatibility (arguments)
+ if (isArrayLike(source)) {
+ return indexKeys(source, has);
+ }
+
+ return objectKeys(source);
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = keys;
+
+},{}],12:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var each = require('@ndhoule/each');
+
+/**
+ * Produce a new array by passing each value in the input `collection` through a transformative
+ * `iterator` function. The `iterator` function is passed three arguments:
+ * `(value, index, collection)`.
+ *
+ * @name map
+ * @api public
+ * @param {Function} iterator The transformer function to invoke per iteration.
+ * @param {Array} collection The collection to iterate over.
+ * @return {Array} A new array containing the results of each `iterator` invocation.
+ * @example
+ * var square = function(x) { return x * x; };
+ *
+ * map(square, [1, 2, 3]);
+ * //=> [1, 4, 9]
+ */
+var map = function map(iterator, collection) {
+ if (typeof iterator !== 'function') {
+ throw new TypeError('Expected a function but received a ' + typeof iterator);
+ }
+
+ var result = [];
+
+ each(function(val, i, collection) {
+ result.push(iterator(val, i, collection));
+ }, collection);
+
+ return result;
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = map;
+
+},{"@ndhoule/each":6}],13:[function(require,module,exports){
+'use strict';
+
+var objToString = Object.prototype.toString;
+
+// TODO: Move to lib
+var existy = function(val) {
+ return val != null;
+};
+
+// TODO: Move to lib
+var isArray = function(val) {
+ return objToString.call(val) === '[object Array]';
+};
+
+// TODO: Move to lib
+var isString = function(val) {
+ return typeof val === 'string' || objToString.call(val) === '[object String]';
+};
+
+// TODO: Move to lib
+var isObject = function(val) {
+ return val != null && typeof val === 'object';
+};
+
+/**
+ * Returns a copy of the new `object` containing only the specified properties.
+ *
+ * @name pick
+ * @api public
+ * @param {string|string[]} props The property or properties to keep.
+ * @param {Object} object The object to iterate over.
+ * @return {Object} A new object containing only the specified properties from `object`.
+ * @example
+ * var person = { name: 'Tim', occupation: 'enchanter', fears: 'rabbits' };
+ *
+ * pick('name', person);
+ * //=> { name: 'Tim' }
+ *
+ * pick(['name', 'fears'], person);
+ * //=> { name: 'Tim', fears: 'rabbits' }
+ */
+var pick = function pick(props, object) {
+ if (!existy(object) || !isObject(object)) {
+ return {};
+ }
+
+ if (isString(props)) {
+ props = [props];
+ }
+
+ if (!isArray(props)) {
+ props = [];
+ }
+
+ var result = {};
+
+ for (var i = 0; i < props.length; i += 1) {
+ if (isString(props[i]) && props[i] in object) {
+ result[props[i]] = object[props[i]];
+ }
+ }
+
+ return result;
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = pick;
+
+},{}],14:[function(require,module,exports){
+'use strict';
+
+var max = Math.max;
+
+/**
+ * Produce a new array by passing each value in the input `collection` through a transformative
+ * `iterator` function. The `iterator` function is passed three arguments:
+ * `(value, index, collection)`.
+ *
+ * @name rest
+ * @api public
+ * @param {Array} collection The collection to iterate over.
+ * @return {Array} A new array containing all but the first element from `collection`.
+ * @example
+ * rest([1, 2, 3]); // => [2, 3]
+ */
+var rest = function rest(collection) {
+ if (collection == null || !collection.length) {
+ return [];
+ }
+
+ // Preallocating an array *significantly* boosts performance when dealing with
+ // `arguments` objects on v8. For a summary, see:
+ // https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments
+ var results = new Array(max(collection.length - 2, 0));
+
+ for (var i = 1; i < collection.length; i += 1) {
+ results[i - 1] = collection[i];
+ }
+
+ return results;
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = rest;
+
+},{}],15:[function(require,module,exports){
+(function (global){(function (){
+'use strict';
+
+var _analytics = global.analytics;
+
+/*
+ * Module dependencies.
+ */
+
+var Alias = require('segmentio-facade').Alias;
+var Emitter = require('component-emitter');
+var Facade = require('segmentio-facade');
+var Group = require('segmentio-facade').Group;
+var Identify = require('segmentio-facade').Identify;
+var SourceMiddlewareChain = require('./middleware').SourceMiddlewareChain;
+var IntegrationMiddlewareChain = require('./middleware')
+ .IntegrationMiddlewareChain;
+var Page = require('segmentio-facade').Page;
+var Track = require('segmentio-facade').Track;
+var bindAll = require('bind-all');
+var clone = require('@ndhoule/clone');
+var extend = require('extend');
+var cookie = require('./cookie');
+var metrics = require('./metrics');
+var debug = require('debug');
+var defaults = require('@ndhoule/defaults');
+var each = require('@ndhoule/each');
+var foldl = require('@ndhoule/foldl');
+var group = require('./group');
+var is = require('is');
+var isMeta = require('@segment/is-meta');
+var keys = require('@ndhoule/keys');
+var memory = require('./memory');
+var nextTick = require('next-tick');
+var normalize = require('./normalize');
+var on = require('component-event').bind;
+var pageDefaults = require('./pageDefaults');
+var pick = require('@ndhoule/pick');
+var prevent = require('@segment/prevent-default');
+var querystring = require('component-querystring');
+var store = require('./store');
+var user = require('./user');
+var type = require('component-type');
+
+/**
+ * Initialize a new `Analytics` instance.
+ */
+
+function Analytics() {
+ this._options({});
+ this.Integrations = {};
+ this._sourceMiddlewares = new SourceMiddlewareChain();
+ this._integrationMiddlewares = new IntegrationMiddlewareChain();
+ this._integrations = {};
+ this._readied = false;
+ this._timeout = 300;
+ // XXX: BACKWARDS COMPATIBILITY
+ this._user = user;
+ this.log = debug('analytics.js');
+ bindAll(this);
+
+ var self = this;
+ this.on('initialize', function(settings, options) {
+ if (options.initialPageview) self.page();
+ self._parseQuery(window.location.search);
+ });
+}
+
+/**
+ * Mix in event emitter.
+ */
+
+Emitter(Analytics.prototype);
+
+/**
+ * Use a `plugin`.
+ *
+ * @param {Function} plugin
+ * @return {Analytics}
+ */
+
+Analytics.prototype.use = function(plugin) {
+ plugin(this);
+ return this;
+};
+
+/**
+ * Define a new `Integration`.
+ *
+ * @param {Function} Integration
+ * @return {Analytics}
+ */
+
+Analytics.prototype.addIntegration = function(Integration) {
+ var name = Integration.prototype.name;
+ if (!name) throw new TypeError('attempted to add an invalid integration');
+ this.Integrations[name] = Integration;
+ return this;
+};
+
+/**
+ * Define a new `SourceMiddleware`
+ *
+ * @param {Function} Middleware
+ * @return {Analytics}
+ */
+
+Analytics.prototype.addSourceMiddleware = function(middleware) {
+ if (this.initialized)
+ throw new Error(
+ 'attempted to add a source middleware after initialization'
+ );
+
+ this._sourceMiddlewares.add(middleware);
+ return this;
+};
+
+/**
+ * Define a new `IntegrationMiddleware`
+ *
+ * @param {Function} Middleware
+ * @return {Analytics}
+ */
+
+Analytics.prototype.addIntegrationMiddleware = function(middleware) {
+ if (this.initialized)
+ throw new Error(
+ 'attempted to add an integration middleware after initialization'
+ );
+
+ this._integrationMiddlewares.add(middleware);
+ return this;
+};
+
+/**
+ * Initialize with the given integration `settings` and `options`.
+ *
+ * Aliased to `init` for convenience.
+ *
+ * @param {Object} [settings={}]
+ * @param {Object} [options={}]
+ * @return {Analytics}
+ */
+
+Analytics.prototype.init = Analytics.prototype.initialize = function(
+ settings,
+ options
+) {
+ settings = settings || {};
+ options = options || {};
+
+ this._options(options);
+ this._readied = false;
+
+ // clean unknown integrations from settings
+ var self = this;
+ each(function(opts, name) {
+ var Integration = self.Integrations[name];
+ if (!Integration) delete settings[name];
+ }, settings);
+
+ // add integrations
+ each(function(opts, name) {
+ // Don't load disabled integrations
+ if (options.integrations) {
+ if (
+ options.integrations[name] === false ||
+ (options.integrations.All === false && !options.integrations[name])
+ ) {
+ return;
+ }
+ }
+
+ var Integration = self.Integrations[name];
+ var clonedOpts = {};
+ extend(true, clonedOpts, opts); // deep clone opts
+ var integration = new Integration(clonedOpts);
+ self.log('initialize %o - %o', name, opts);
+ self.add(integration);
+ }, settings);
+
+ var integrations = this._integrations;
+
+ // load user now that options are set
+ user.load();
+ group.load();
+
+ // make ready callback
+ var readyCallCount = 0;
+ var integrationCount = keys(integrations).length;
+ var ready = function() {
+ readyCallCount++;
+ if (readyCallCount >= integrationCount) {
+ self._readied = true;
+ self.emit('ready');
+ }
+ };
+
+ // init if no integrations
+ if (integrationCount <= 0) {
+ ready();
+ }
+
+ // initialize integrations, passing ready
+ // create a list of any integrations that did not initialize - this will be passed with all events for replay support:
+ this.failedInitializations = [];
+ var initialPageSkipped = false;
+ each(function(integration) {
+ if (
+ options.initialPageview &&
+ integration.options.initialPageview === false
+ ) {
+ // We've assumed one initial pageview, so make sure we don't count the first page call.
+ var page = integration.page;
+ integration.page = function() {
+ if (initialPageSkipped) {
+ return page.apply(this, arguments);
+ }
+ initialPageSkipped = true;
+ return;
+ };
+ }
+
+ integration.analytics = self;
+
+ integration.once('ready', ready);
+ try {
+ metrics.increment('analytics_js.integration.invoke', {
+ method: 'initialize',
+ integration_name: integration.name
+ });
+ integration.initialize();
+ } catch (e) {
+ var integrationName = integration.name;
+ metrics.increment('analytics_js.integration.invoke.error', {
+ method: 'initialize',
+ integration_name: integration.name
+ });
+ self.failedInitializations.push(integrationName);
+ self.log('Error initializing %s integration: %o', integrationName, e);
+ // Mark integration as ready to prevent blocking of anyone listening to analytics.ready()
+
+ integration.ready();
+ }
+ }, integrations);
+
+ // backwards compat with angular plugin and used for init logic checks
+ this.initialized = true;
+
+ this.emit('initialize', settings, options);
+ return this;
+};
+
+/**
+ * Set the user's `id`.
+ *
+ * @param {Mixed} id
+ */
+
+Analytics.prototype.setAnonymousId = function(id) {
+ this.user().anonymousId(id);
+ return this;
+};
+
+/**
+ * Add an integration.
+ *
+ * @param {Integration} integration
+ */
+
+Analytics.prototype.add = function(integration) {
+ this._integrations[integration.name] = integration;
+ return this;
+};
+
+/**
+ * Identify a user by optional `id` and `traits`.
+ *
+ * @param {string} [id=user.id()] User ID.
+ * @param {Object} [traits=null] User traits.
+ * @param {Object} [options=null]
+ * @param {Function} [fn]
+ * @return {Analytics}
+ */
+
+Analytics.prototype.identify = function(id, traits, options, fn) {
+ // Argument reshuffling.
+ /* eslint-disable no-unused-expressions, no-sequences */
+ if (is.fn(options)) (fn = options), (options = null);
+ if (is.fn(traits)) (fn = traits), (options = null), (traits = null);
+ if (is.object(id)) (options = traits), (traits = id), (id = user.id());
+ /* eslint-enable no-unused-expressions, no-sequences */
+
+ // clone traits before we manipulate so we don't do anything uncouth, and take
+ // from `user` so that we carryover anonymous traits
+ user.identify(id, traits);
+
+ var msg = this.normalize({
+ options: options,
+ traits: user.traits(),
+ userId: user.id()
+ });
+
+ // Add the initialize integrations so the server-side ones can be disabled too
+ if (this.options.integrations) {
+ defaults(msg.integrations, this.options.integrations);
+ }
+
+ this._invoke('identify', new Identify(msg));
+
+ // emit
+ this.emit('identify', id, traits, options);
+ this._callback(fn);
+ return this;
+};
+
+/**
+ * Return the current user.
+ *
+ * @return {Object}
+ */
+
+Analytics.prototype.user = function() {
+ return user;
+};
+
+/**
+ * Identify a group by optional `id` and `traits`. Or, if no arguments are
+ * supplied, return the current group.
+ *
+ * @param {string} [id=group.id()] Group ID.
+ * @param {Object} [traits=null] Group traits.
+ * @param {Object} [options=null]
+ * @param {Function} [fn]
+ * @return {Analytics|Object}
+ */
+
+Analytics.prototype.group = function(id, traits, options, fn) {
+ /* eslint-disable no-unused-expressions, no-sequences */
+ if (!arguments.length) return group;
+ if (is.fn(options)) (fn = options), (options = null);
+ if (is.fn(traits)) (fn = traits), (options = null), (traits = null);
+ if (is.object(id)) (options = traits), (traits = id), (id = group.id());
+ /* eslint-enable no-unused-expressions, no-sequences */
+
+ // grab from group again to make sure we're taking from the source
+ group.identify(id, traits);
+
+ var msg = this.normalize({
+ options: options,
+ traits: group.traits(),
+ groupId: group.id()
+ });
+
+ // Add the initialize integrations so the server-side ones can be disabled too
+ if (this.options.integrations) {
+ defaults(msg.integrations, this.options.integrations);
+ }
+
+ this._invoke('group', new Group(msg));
+
+ this.emit('group', id, traits, options);
+ this._callback(fn);
+ return this;
+};
+
+/**
+ * Track an `event` that a user has triggered with optional `properties`.
+ *
+ * @param {string} event
+ * @param {Object} [properties=null]
+ * @param {Object} [options=null]
+ * @param {Function} [fn]
+ * @return {Analytics}
+ */
+
+Analytics.prototype.track = function(event, properties, options, fn) {
+ // Argument reshuffling.
+ /* eslint-disable no-unused-expressions, no-sequences */
+ if (is.fn(options)) (fn = options), (options = null);
+ if (is.fn(properties))
+ (fn = properties), (options = null), (properties = null);
+ /* eslint-enable no-unused-expressions, no-sequences */
+
+ // figure out if the event is archived.
+ var plan = this.options.plan || {};
+ var events = plan.track || {};
+ var planIntegrationOptions = {};
+
+ // normalize
+ var msg = this.normalize({
+ properties: properties,
+ options: options,
+ event: event
+ });
+
+ // plan.
+ plan = events[event];
+ if (plan) {
+ this.log('plan %o - %o', event, plan);
+ if (plan.enabled === false) {
+ // Disabled events should always be sent to Segment.
+ planIntegrationOptions = { All: false, 'Segment.io': true };
+ } else {
+ planIntegrationOptions = plan.integrations || {};
+ }
+ } else {
+ var defaultPlan = events.__default || { enabled: true };
+ if (!defaultPlan.enabled) {
+ // Disabled events should always be sent to Segment.
+ planIntegrationOptions = { All: false, 'Segment.io': true };
+ }
+ }
+
+ // Add the initialize integrations so the server-side ones can be disabled too
+ defaults(
+ msg.integrations,
+ this._mergeInitializeAndPlanIntegrations(planIntegrationOptions)
+ );
+
+ this._invoke('track', new Track(msg));
+
+ this.emit('track', event, properties, options);
+ this._callback(fn);
+ return this;
+};
+
+/**
+ * Helper method to track an outbound link that would normally navigate away
+ * from the page before the analytics calls were sent.
+ *
+ * BACKWARDS COMPATIBILITY: aliased to `trackClick`.
+ *
+ * @param {Element|Array} links
+ * @param {string|Function} event
+ * @param {Object|Function} properties (optional)
+ * @return {Analytics}
+ */
+
+Analytics.prototype.trackClick = Analytics.prototype.trackLink = function(
+ links,
+ event,
+ properties
+) {
+ if (!links) return this;
+ // always arrays, handles jquery
+ if (type(links) === 'element') links = [links];
+
+ var self = this;
+ each(function(el) {
+ if (type(el) !== 'element') {
+ throw new TypeError('Must pass HTMLElement to `analytics.trackLink`.');
+ }
+ on(el, 'click', function(e) {
+ var ev = is.fn(event) ? event(el) : event;
+ var props = is.fn(properties) ? properties(el) : properties;
+ var href =
+ el.getAttribute('href') ||
+ el.getAttributeNS('http://www.w3.org/1999/xlink', 'href') ||
+ el.getAttribute('xlink:href');
+
+ self.track(ev, props);
+
+ if (href && el.target !== '_blank' && !isMeta(e)) {
+ prevent(e);
+ self._callback(function() {
+ window.location.href = href;
+ });
+ }
+ });
+ }, links);
+
+ return this;
+};
+
+/**
+ * Helper method to track an outbound form that would normally navigate away
+ * from the page before the analytics calls were sent.
+ *
+ * BACKWARDS COMPATIBILITY: aliased to `trackSubmit`.
+ *
+ * @param {Element|Array} forms
+ * @param {string|Function} event
+ * @param {Object|Function} properties (optional)
+ * @return {Analytics}
+ */
+
+Analytics.prototype.trackSubmit = Analytics.prototype.trackForm = function(
+ forms,
+ event,
+ properties
+) {
+ if (!forms) return this;
+ // always arrays, handles jquery
+ if (type(forms) === 'element') forms = [forms];
+
+ var self = this;
+ each(function(el) {
+ if (type(el) !== 'element')
+ throw new TypeError('Must pass HTMLElement to `analytics.trackForm`.');
+ function handler(e) {
+ prevent(e);
+
+ var ev = is.fn(event) ? event(el) : event;
+ var props = is.fn(properties) ? properties(el) : properties;
+ self.track(ev, props);
+
+ self._callback(function() {
+ el.submit();
+ });
+ }
+
+ // Support the events happening through jQuery or Zepto instead of through
+ // the normal DOM API, because `el.submit` doesn't bubble up events...
+ var $ = window.jQuery || window.Zepto;
+ if ($) {
+ $(el).submit(handler);
+ } else {
+ on(el, 'submit', handler);
+ }
+ }, forms);
+
+ return this;
+};
+
+/**
+ * Trigger a pageview, labeling the current page with an optional `category`,
+ * `name` and `properties`.
+ *
+ * @param {string} [category]
+ * @param {string} [name]
+ * @param {Object|string} [properties] (or path)
+ * @param {Object} [options]
+ * @param {Function} [fn]
+ * @return {Analytics}
+ */
+
+Analytics.prototype.page = function(category, name, properties, options, fn) {
+ // Argument reshuffling.
+ /* eslint-disable no-unused-expressions, no-sequences */
+ if (is.fn(options)) (fn = options), (options = null);
+ if (is.fn(properties)) (fn = properties), (options = properties = null);
+ if (is.fn(name)) (fn = name), (options = properties = name = null);
+ if (type(category) === 'object')
+ (options = name), (properties = category), (name = category = null);
+ if (type(name) === 'object')
+ (options = properties), (properties = name), (name = null);
+ if (type(category) === 'string' && type(name) !== 'string')
+ (name = category), (category = null);
+ /* eslint-enable no-unused-expressions, no-sequences */
+
+ properties = clone(properties) || {};
+ if (name) properties.name = name;
+ if (category) properties.category = category;
+
+ // Ensure properties has baseline spec properties.
+ // TODO: Eventually move these entirely to `options.context.page`
+ var defs = pageDefaults();
+ defaults(properties, defs);
+
+ // Mirror user overrides to `options.context.page` (but exclude custom properties)
+ // (Any page defaults get applied in `this.normalize` for consistency.)
+ // Weird, yeah--moving special props to `context.page` will fix this in the long term.
+ var overrides = pick(keys(defs), properties);
+ if (!is.empty(overrides)) {
+ options = options || {};
+ options.context = options.context || {};
+ options.context.page = overrides;
+ }
+
+ var msg = this.normalize({
+ properties: properties,
+ category: category,
+ options: options,
+ name: name
+ });
+
+ // Add the initialize integrations so the server-side ones can be disabled too
+ if (this.options.integrations) {
+ defaults(msg.integrations, this.options.integrations);
+ }
+
+ this._invoke('page', new Page(msg));
+
+ this.emit('page', category, name, properties, options);
+ this._callback(fn);
+ return this;
+};
+
+/**
+ * FIXME: BACKWARDS COMPATIBILITY: convert an old `pageview` to a `page` call.
+ *
+ * @param {string} [url]
+ * @return {Analytics}
+ * @api private
+ */
+
+Analytics.prototype.pageview = function(url) {
+ var properties = {};
+ if (url) properties.path = url;
+ this.page(properties);
+ return this;
+};
+
+/**
+ * Merge two previously unassociated user identities.
+ *
+ * @param {string} to
+ * @param {string} from (optional)
+ * @param {Object} options (optional)
+ * @param {Function} fn (optional)
+ * @return {Analytics}
+ */
+
+Analytics.prototype.alias = function(to, from, options, fn) {
+ // Argument reshuffling.
+ /* eslint-disable no-unused-expressions, no-sequences */
+ if (is.fn(options)) (fn = options), (options = null);
+ if (is.fn(from)) (fn = from), (options = null), (from = null);
+ if (is.object(from)) (options = from), (from = null);
+ /* eslint-enable no-unused-expressions, no-sequences */
+
+ var msg = this.normalize({
+ options: options,
+ previousId: from,
+ userId: to
+ });
+
+ // Add the initialize integrations so the server-side ones can be disabled too
+ if (this.options.integrations) {
+ defaults(msg.integrations, this.options.integrations);
+ }
+
+ this._invoke('alias', new Alias(msg));
+
+ this.emit('alias', to, from, options);
+ this._callback(fn);
+ return this;
+};
+
+/**
+ * Register a `fn` to be fired when all the analytics services are ready.
+ *
+ * @param {Function} fn
+ * @return {Analytics}
+ */
+
+Analytics.prototype.ready = function(fn) {
+ if (is.fn(fn)) {
+ if (this._readied) {
+ nextTick(fn);
+ } else {
+ this.once('ready', fn);
+ }
+ }
+ return this;
+};
+
+/**
+ * Set the `timeout` (in milliseconds) used for callbacks.
+ *
+ * @param {Number} timeout
+ */
+
+Analytics.prototype.timeout = function(timeout) {
+ this._timeout = timeout;
+};
+
+/**
+ * Enable or disable debug.
+ *
+ * @param {string|boolean} str
+ */
+
+Analytics.prototype.debug = function(str) {
+ if (!arguments.length || str) {
+ debug.enable('analytics:' + (str || '*'));
+ } else {
+ debug.disable();
+ }
+};
+
+/**
+ * Apply options.
+ *
+ * @param {Object} options
+ * @return {Analytics}
+ * @api private
+ */
+
+Analytics.prototype._options = function(options) {
+ options = options || {};
+ this.options = options;
+ cookie.options(options.cookie);
+ metrics.options(options.metrics);
+ store.options(options.localStorage);
+ user.options(options.user);
+ group.options(options.group);
+ return this;
+};
+
+/**
+ * Callback a `fn` after our defined timeout period.
+ *
+ * @param {Function} fn
+ * @return {Analytics}
+ * @api private
+ */
+
+Analytics.prototype._callback = function(fn) {
+ if (is.fn(fn)) {
+ this._timeout ? setTimeout(fn, this._timeout) : nextTick(fn);
+ }
+ return this;
+};
+
+/**
+ * Call `method` with `facade` on all enabled integrations.
+ *
+ * @param {string} method
+ * @param {Facade} facade
+ * @return {Analytics}
+ * @api private
+ */
+
+Analytics.prototype._invoke = function(method, facade) {
+ var self = this;
+
+ try {
+ this._sourceMiddlewares.applyMiddlewares(
+ extend(true, new Facade({}), facade),
+ this._integrations,
+ function(result) {
+ // A nullified payload should not be sent.
+ if (result === null) {
+ self.log(
+ 'Payload with method "%s" was null and dropped by source a middleware.',
+ method
+ );
+ return;
+ }
+
+ // Check if the payload is still a Facade. If not, convert it to one.
+ if (!(result instanceof Facade)) {
+ result = new Facade(result);
+ }
+
+ self.emit('invoke', result);
+ metrics.increment('analytics_js.invoke', {
+ method: method
+ });
+
+ applyIntegrationMiddlewares(result);
+ }
+ );
+ } catch (e) {
+ metrics.increment('analytics_js.invoke.error', {
+ method: method
+ });
+ self.log(
+ 'Error invoking .%s method of %s integration: %o',
+ method,
+ name,
+ e
+ );
+ }
+
+ return this;
+
+ function applyIntegrationMiddlewares(facade) {
+ var failedInitializations = self.failedInitializations || [];
+ each(function(integration, name) {
+ var facadeCopy = extend(true, new Facade({}), facade);
+
+ if (!facadeCopy.enabled(name)) return;
+ // Check if an integration failed to initialize.
+ // If so, do not process the message as the integration is in an unstable state.
+ if (failedInitializations.indexOf(name) >= 0) {
+ self.log(
+ 'Skipping invocation of .%s method of %s integration. Integration failed to initialize properly.',
+ method,
+ name
+ );
+ } else {
+ try {
+ // Apply any integration middlewares that exist, then invoke the integration with the result.
+ self._integrationMiddlewares.applyMiddlewares(
+ facadeCopy,
+ integration.name,
+ function(result) {
+ // A nullified payload should not be sent to an integration.
+ if (result === null) {
+ self.log(
+ 'Payload to integration "%s" was null and dropped by a middleware.',
+ name
+ );
+ return;
+ }
+
+ // Check if the payload is still a Facade. If not, convert it to one.
+ if (!(result instanceof Facade)) {
+ result = new Facade(result);
+ }
+
+ metrics.increment('analytics_js.integration.invoke', {
+ method: method,
+ integration_name: integration.name
+ });
+
+ integration.invoke.call(integration, method, result);
+ }
+ );
+ } catch (e) {
+ metrics.increment('analytics_js.integration.invoke.error', {
+ method: method,
+ integration_name: integration.name
+ });
+ self.log(
+ 'Error invoking .%s method of %s integration: %o',
+ method,
+ name,
+ e
+ );
+ }
+ }
+ }, self._integrations);
+ }
+};
+
+/**
+ * Push `args`.
+ *
+ * @param {Array} args
+ * @api private
+ */
+
+Analytics.prototype.push = function(args) {
+ var method = args.shift();
+ if (!this[method]) return;
+ this[method].apply(this, args);
+};
+
+/**
+ * Reset group and user traits and id's.
+ *
+ * @api public
+ */
+
+Analytics.prototype.reset = function() {
+ this.user().logout();
+ this.group().logout();
+};
+
+/**
+ * Parse the query string for callable methods.
+ *
+ * @param {String} query
+ * @return {Analytics}
+ * @api private
+ */
+
+Analytics.prototype._parseQuery = function(query) {
+ // Parse querystring to an object
+ var q = querystring.parse(query);
+ // Create traits and properties objects, populate from querysting params
+ var traits = pickPrefix('ajs_trait_', q);
+ var props = pickPrefix('ajs_prop_', q);
+ // Trigger based on callable parameters in the URL
+ if (q.ajs_uid) this.identify(q.ajs_uid, traits);
+ if (q.ajs_event) this.track(q.ajs_event, props);
+ if (q.ajs_aid) user.anonymousId(q.ajs_aid);
+ return this;
+
+ /**
+ * Create a shallow copy of an input object containing only the properties
+ * whose keys are specified by a prefix, stripped of that prefix
+ *
+ * @param {String} prefix
+ * @param {Object} object
+ * @return {Object}
+ * @api private
+ */
+
+ function pickPrefix(prefix, object) {
+ var length = prefix.length;
+ var sub;
+ return foldl(
+ function(acc, val, key) {
+ if (key.substr(0, length) === prefix) {
+ sub = key.substr(length);
+ acc[sub] = val;
+ }
+ return acc;
+ },
+ {},
+ object
+ );
+ }
+};
+
+/**
+ * Normalize the given `msg`.
+ *
+ * @param {Object} msg
+ * @return {Object}
+ */
+
+Analytics.prototype.normalize = function(msg) {
+ msg = normalize(msg, keys(this._integrations));
+ if (msg.anonymousId) user.anonymousId(msg.anonymousId);
+ msg.anonymousId = user.anonymousId();
+
+ // Ensure all outgoing requests include page data in their contexts.
+ msg.context.page = defaults(msg.context.page || {}, pageDefaults());
+
+ return msg;
+};
+
+/**
+ * Merges the tracking plan and initialization integration options.
+ *
+ * @param {Object} planIntegrations Tracking plan integrations.
+ * @return {Object} The merged integrations.
+ */
+Analytics.prototype._mergeInitializeAndPlanIntegrations = function(
+ planIntegrations
+) {
+ // Do nothing if there are no initialization integrations
+ if (!this.options.integrations) {
+ return planIntegrations;
+ }
+
+ // Clone the initialization integrations
+ var integrations = extend({}, this.options.integrations);
+ var integrationName;
+
+ // Allow the tracking plan to disable integrations that were explicitly
+ // enabled on initialization
+ if (planIntegrations.All === false) {
+ integrations = { All: false };
+ }
+
+ for (integrationName in planIntegrations) {
+ if (planIntegrations.hasOwnProperty(integrationName)) {
+ // Don't allow the tracking plan to re-enable disabled integrations
+ if (this.options.integrations[integrationName] !== false) {
+ integrations[integrationName] = planIntegrations[integrationName];
+ }
+ }
+ }
+
+ return integrations;
+};
+
+/**
+ * No conflict support.
+ */
+
+Analytics.prototype.noConflict = function() {
+ window.analytics = _analytics;
+ return this;
+};
+
+/*
+ * Exports.
+ */
+
+module.exports = Analytics;
+module.exports.cookie = cookie;
+module.exports.memory = memory;
+module.exports.store = store;
+module.exports.metrics = metrics;
+
+}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./cookie":16,"./group":18,"./memory":20,"./metrics":21,"./middleware":22,"./normalize":23,"./pageDefaults":24,"./store":25,"./user":26,"@ndhoule/clone":3,"@ndhoule/defaults":4,"@ndhoule/each":6,"@ndhoule/foldl":9,"@ndhoule/keys":11,"@ndhoule/pick":13,"@segment/is-meta":35,"@segment/prevent-default":39,"bind-all":44,"component-emitter":52,"component-event":53,"component-querystring":55,"component-type":57,"debug":27,"extend":62,"is":66,"next-tick":76,"segmentio-facade":86}],16:[functi [...]
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+var bindAll = require('bind-all');
+var clone = require('@ndhoule/clone');
+var cookie = require('component-cookie');
+var debug = require('debug')('analytics.js:cookie');
+var defaults = require('@ndhoule/defaults');
+var json = require('json3');
+var topDomain = require('@segment/top-domain');
+
+/**
+ * Initialize a new `Cookie` with `options`.
+ *
+ * @param {Object} options
+ */
+
+function Cookie(options) {
+ this.options(options);
+}
+
+/**
+ * Get or set the cookie options.
+ *
+ * @param {Object} options
+ * @field {Number} maxage (1 year)
+ * @field {String} domain
+ * @field {String} path
+ * @field {Boolean} secure
+ */
+
+Cookie.prototype.options = function(options) {
+ if (arguments.length === 0) return this._options;
+
+ options = options || {};
+
+ var domain = '.' + topDomain(window.location.href);
+ if (domain === '.') domain = null;
+
+ this._options = defaults(options, {
+ // default to a year
+ maxage: 31536000000,
+ path: '/',
+ domain: domain
+ });
+
+ // http://curl.haxx.se/rfc/cookie_spec.html
+ // https://publicsuffix.org/list/effective_tld_names.dat
+ //
+ // try setting a dummy cookie with the options
+ // if the cookie isn't set, it probably means
+ // that the domain is on the public suffix list
+ // like myapp.herokuapp.com or localhost / ip.
+ this.set('ajs:test', true);
+ if (!this.get('ajs:test')) {
+ debug('fallback to domain=null');
+ this._options.domain = null;
+ }
+ this.remove('ajs:test');
+};
+
+/**
+ * Set a `key` and `value` in our cookie.
+ *
+ * @param {String} key
+ * @param {Object} value
+ * @return {Boolean} saved
+ */
+
+Cookie.prototype.set = function(key, value) {
+ try {
+ value = json.stringify(value);
+ cookie(key, value, clone(this._options));
+ return true;
+ } catch (e) {
+ return false;
+ }
+};
+
+/**
+ * Get a value from our cookie by `key`.
+ *
+ * @param {String} key
+ * @return {Object} value
+ */
+
+Cookie.prototype.get = function(key) {
+ try {
+ var value = cookie(key);
+ value = value ? json.parse(value) : null;
+ return value;
+ } catch (e) {
+ return null;
+ }
+};
+
+/**
+ * Remove a value from our cookie by `key`.
+ *
+ * @param {String} key
+ * @return {Boolean} removed
+ */
+
+Cookie.prototype.remove = function(key) {
+ try {
+ cookie(key, null, clone(this._options));
+ return true;
+ } catch (e) {
+ return false;
+ }
+};
+
+/**
+ * Expose the cookie singleton.
+ */
+
+module.exports = bindAll(new Cookie());
+
+/**
+ * Expose the `Cookie` constructor.
+ */
+
+module.exports.Cookie = Cookie;
+
+},{"@ndhoule/clone":3,"@ndhoule/defaults":4,"@segment/top-domain":42,"bind-all":44,"component-cookie":46,"debug":27,"json3":67}],17:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var clone = require('@ndhoule/clone');
+var cookie = require('./cookie');
+var debug = require('debug')('analytics:entity');
+var defaults = require('@ndhoule/defaults');
+var extend = require('@ndhoule/extend');
+var memory = require('./memory');
+var store = require('./store');
+var isodateTraverse = require('@segment/isodate-traverse');
+
+/**
+ * Expose `Entity`
+ */
+
+module.exports = Entity;
+
+/**
+ * Initialize new `Entity` with `options`.
+ *
+ * @param {Object} options
+ */
+
+function Entity(options) {
+ this.options(options);
+ this.initialize();
+}
+
+/**
+ * Initialize picks the storage.
+ *
+ * Checks to see if cookies can be set
+ * otherwise fallsback to localStorage.
+ */
+
+Entity.prototype.initialize = function() {
+ cookie.set('ajs:cookies', true);
+
+ // cookies are enabled.
+ if (cookie.get('ajs:cookies')) {
+ cookie.remove('ajs:cookies');
+ this._storage = cookie;
+ return;
+ }
+
+ // localStorage is enabled.
+ if (store.enabled) {
+ this._storage = store;
+ return;
+ }
+
+ // fallback to memory storage.
+ debug(
+ 'warning using memory store both cookies and localStorage are disabled'
+ );
+ this._storage = memory;
+};
+
+/**
+ * Get the storage.
+ */
+
+Entity.prototype.storage = function() {
+ return this._storage;
+};
+
+/**
+ * Get or set storage `options`.
+ *
+ * @param {Object} options
+ * @property {Object} cookie
+ * @property {Object} localStorage
+ * @property {Boolean} persist (default: `true`)
+ */
+
+Entity.prototype.options = function(options) {
+ if (arguments.length === 0) return this._options;
+ this._options = defaults(options || {}, this.defaults || {});
+};
+
+/**
+ * Get or set the entity's `id`.
+ *
+ * @param {String} id
+ */
+
+Entity.prototype.id = function(id) {
+ switch (arguments.length) {
+ case 0:
+ return this._getId();
+ case 1:
+ return this._setId(id);
+ default:
+ // No default case
+ }
+};
+
+/**
+ * Get the entity's id.
+ *
+ * @return {String}
+ */
+
+Entity.prototype._getId = function() {
+ if (!this._options.persist) {
+ return this._id === undefined ? null : this._id;
+ }
+
+ // Check cookies.
+ var cookieId = this._getIdFromCookie();
+ if (cookieId) {
+ return cookieId;
+ }
+
+ // Check localStorage.
+ var lsId = this._getIdFromLocalStorage();
+ if (lsId) {
+ // Copy the id to cookies so we can read it directly from cookies next time.
+ this._setIdInCookies(lsId);
+ return lsId;
+ }
+
+ return null;
+};
+
+/**
+ * Get the entity's id from cookies.
+ *
+ * @return {String}
+ */
+
+Entity.prototype._getIdFromCookie = function() {
+ return this.storage().get(this._options.cookie.key);
+};
+
+/**
+ * Get the entity's id from cookies.
+ *
+ * @return {String}
+ */
+
+Entity.prototype._getIdFromLocalStorage = function() {
+ if (!this._options.localStorageFallbackDisabled) {
+ return store.get(this._options.cookie.key);
+ }
+ return null;
+};
+
+/**
+ * Set the entity's `id`.
+ *
+ * @param {String} id
+ */
+
+Entity.prototype._setId = function(id) {
+ if (this._options.persist) {
+ this._setIdInCookies(id);
+ this._setIdInLocalStorage(id);
+ } else {
+ this._id = id;
+ }
+};
+
+/**
+ * Set the entity's `id` in cookies.
+ *
+ * @param {String} id
+ */
+
+Entity.prototype._setIdInCookies = function(id) {
+ this.storage().set(this._options.cookie.key, id);
+};
+
+/**
+ * Set the entity's `id` in local storage.
+ *
+ * @param {String} id
+ */
+
+Entity.prototype._setIdInLocalStorage = function(id) {
+ if (!this._options.localStorageFallbackDisabled) {
+ store.set(this._options.cookie.key, id);
+ }
+};
+
+/**
+ * Get or set the entity's `traits`.
+ *
+ * BACKWARDS COMPATIBILITY: aliased to `properties`
+ *
+ * @param {Object} traits
+ */
+
+Entity.prototype.properties = Entity.prototype.traits = function(traits) {
+ switch (arguments.length) {
+ case 0:
+ return this._getTraits();
+ case 1:
+ return this._setTraits(traits);
+ default:
+ // No default case
+ }
+};
+
+/**
+ * Get the entity's traits. Always convert ISO date strings into real dates,
+ * since they aren't parsed back from local storage.
+ *
+ * @return {Object}
+ */
+
+Entity.prototype._getTraits = function() {
+ var ret = this._options.persist
+ ? store.get(this._options.localStorage.key)
+ : this._traits;
+ return ret ? isodateTraverse(clone(ret)) : {};
+};
+
+/**
+ * Set the entity's `traits`.
+ *
+ * @param {Object} traits
+ */
+
+Entity.prototype._setTraits = function(traits) {
+ traits = traits || {};
+ if (this._options.persist) {
+ store.set(this._options.localStorage.key, traits);
+ } else {
+ this._traits = traits;
+ }
+};
+
+/**
+ * Identify the entity with an `id` and `traits`. If we it's the same entity,
+ * extend the existing `traits` instead of overwriting.
+ *
+ * @param {String} id
+ * @param {Object} traits
+ */
+
+Entity.prototype.identify = function(id, traits) {
+ traits = traits || {};
+ var current = this.id();
+ if (current === null || current === id)
+ traits = extend(this.traits(), traits);
+ if (id) this.id(id);
+ this.debug('identify %o, %o', id, traits);
+ this.traits(traits);
+ this.save();
+};
+
+/**
+ * Save the entity to local storage and the cookie.
+ *
+ * @return {Boolean}
+ */
+
+Entity.prototype.save = function() {
+ if (!this._options.persist) return false;
+ this._setId(this.id());
+ this._setTraits(this.traits());
+ return true;
+};
+
+/**
+ * Log the entity out, reseting `id` and `traits` to defaults.
+ */
+
+Entity.prototype.logout = function() {
+ this.id(null);
+ this.traits({});
+ this.storage().remove(this._options.cookie.key);
+ store.remove(this._options.cookie.key);
+ store.remove(this._options.localStorage.key);
+};
+
+/**
+ * Reset all entity state, logging out and returning options to defaults.
+ */
+
+Entity.prototype.reset = function() {
+ this.logout();
+ this.options({});
+};
+
+/**
+ * Load saved entity `id` or `traits` from storage.
+ */
+
+Entity.prototype.load = function() {
+ this.id(this.id());
+ this.traits(this.traits());
+};
+
+},{"./cookie":16,"./memory":20,"./store":25,"@ndhoule/clone":3,"@ndhoule/defaults":4,"@ndhoule/extend":8,"@segment/isodate-traverse":36,"debug":27}],18:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var Entity = require('./entity');
+var bindAll = require('bind-all');
+var debug = require('debug')('analytics:group');
+var inherit = require('inherits');
+
+/**
+ * Group defaults
+ */
+
+Group.defaults = {
+ persist: true,
+ cookie: {
+ key: 'ajs_group_id'
+ },
+ localStorage: {
+ key: 'ajs_group_properties'
+ }
+};
+
+/**
+ * Initialize a new `Group` with `options`.
+ *
+ * @param {Object} options
+ */
+
+function Group(options) {
+ this.defaults = Group.defaults;
+ this.debug = debug;
+ Entity.call(this, options);
+}
+
+/**
+ * Inherit `Entity`
+ */
+
+inherit(Group, Entity);
+
+/**
+ * Expose the group singleton.
+ */
+
+module.exports = bindAll(new Group());
+
+/**
+ * Expose the `Group` constructor.
+ */
+
+module.exports.Group = Group;
+
+},{"./entity":17,"bind-all":44,"debug":27,"inherits":64}],19:[function(require,module,exports){
+'use strict';
+
+/**
+ * Analytics.js
+ *
+ * (C) 2013-2016 Segment.io Inc.
+ */
+
+var Analytics = require('./analytics');
+
+// Create a new `analytics` singleton.
+var analytics = new Analytics();
+
+// Expose `require`.
+// TODO(ndhoule): Look into deprecating, we no longer need to expose it in tests
+//analytics.require = require;
+
+// Expose package version.
+analytics.VERSION = require('../package.json').version;
+
+/*
+ * Exports.
+ */
+
+module.exports = analytics;
+
+},{"../package.json":28,"./analytics":15}],20:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module Dependencies.
+ */
+
+var bindAll = require('bind-all');
+var clone = require('@ndhoule/clone');
+
+/**
+ * HOP.
+ */
+
+var has = Object.prototype.hasOwnProperty;
+
+/**
+ * Expose `Memory`
+ */
+
+module.exports = bindAll(new Memory());
+
+/**
+ * Initialize `Memory` store
+ */
+
+function Memory() {
+ this.store = {};
+}
+
+/**
+ * Set a `key` and `value`.
+ *
+ * @param {String} key
+ * @param {Mixed} value
+ * @return {Boolean}
+ */
+
+Memory.prototype.set = function(key, value) {
+ this.store[key] = clone(value);
+ return true;
+};
+
+/**
+ * Get a `key`.
+ *
+ * @param {String} key
+ */
+
+Memory.prototype.get = function(key) {
+ if (!has.call(this.store, key)) return;
+ return clone(this.store[key]);
+};
+
+/**
+ * Remove a `key`.
+ *
+ * @param {String} key
+ * @return {Boolean}
+ */
+
+Memory.prototype.remove = function(key) {
+ delete this.store[key];
+ return true;
+};
+
+},{"@ndhoule/clone":3,"bind-all":44}],21:[function(require,module,exports){
+'use strict';
+
+var bindAll = require('bind-all');
+var send = require('@segment/send-json');
+var debug = require('debug')('analytics.js:metrics');
+
+function Metrics(options) {
+ this.options(options);
+}
+
+/**
+ * Set the metrics options.
+ *
+ * @param {Object} options
+ * @field {String} host
+ * @field {Number} sampleRate
+ * @field {Number} flushTimer
+ */
+
+Metrics.prototype.options = function(options) {
+ options = options || {};
+
+ this.host = options.host || 'api.segment.io/v1';
+ this.sampleRate = options.sampleRate || 0; // disable metrics by default.
+ this.flushTimer = options.flushTimer || 30 * 1000 /* 30s */;
+ this.maxQueueSize = options.maxQueueSize || 20;
+
+ this.queue = [];
+
+ if (this.sampleRate > 0) {
+ var self = this;
+ setInterval(function() {
+ self._flush();
+ }, this.flushTimer);
+ }
+};
+
+/**
+ * Increments the counter identified by name and tags by one.
+ *
+ * @param {String} metric Name of the metric to increment.
+ * @param {Object} tags Dimensions associated with the metric.
+ */
+Metrics.prototype.increment = function(metric, tags) {
+ if (Math.random() > this.sampleRate) {
+ return;
+ }
+
+ if (this.queue.length >= this.maxQueueSize) {
+ return;
+ }
+
+ this.queue.push({ type: 'Counter', metric: metric, value: 1, tags: tags });
+
+ // Trigger a flush if this is an error metric.
+ if (metric.indexOf('error') > 0) {
+ this._flush();
+ }
+};
+
+/**
+ * Flush all queued metrics.
+ */
+Metrics.prototype._flush = function() {
+ var self = this;
+
+ if (self.queue.length <= 0) {
+ return;
+ }
+
+ var payload = { series: this.queue };
+ var headers = { 'Content-Type': 'text/plain' };
+
+ self.queue = [];
+
+ // This endpoint does not support jsonp, so only proceed if the browser
+ // supports xhr.
+ if (send.type !== 'xhr') return;
+
+ send('https://' + this.host + '/m', payload, headers, function(err, res) {
+ debug('sent %O, received %O', payload, [err, res]);
+ });
+};
+
+/**
+ * Expose the metrics singleton.
+ */
+
+module.exports = bindAll(new Metrics());
+
+/**
+ * Expose the `Metrics` constructor.
+ */
+
+module.exports.Metrics = Metrics;
+
+},{"@segment/send-json":40,"bind-all":44,"debug":27}],22:[function(require,module,exports){
+'use strict';
+
+var Facade = require('segmentio-facade');
+
+module.exports.SourceMiddlewareChain = function SourceMiddlewareChain() {
+ var apply = middlewareChain(this);
+
+ this.applyMiddlewares = function(facade, integrations, callback) {
+ return apply(
+ function(mw, payload, next) {
+ mw({
+ integrations: integrations,
+ next: next,
+ payload: payload
+ });
+ },
+ facade,
+ callback
+ );
+ };
+};
+
+module.exports.IntegrationMiddlewareChain = function IntegrationMiddlewareChain() {
+ var apply = middlewareChain(this);
+
+ this.applyMiddlewares = function(facade, integration, callback) {
+ return apply(
+ function(mw, payload, next) {
+ mw(payload, integration, next);
+ },
+ facade,
+ callback
+ );
+ };
+};
+
+// Chain is essentially a linked list of middlewares to run in order.
+function middlewareChain(dest) {
+ var middlewares = [];
+
+ // Return a copy to prevent external mutations.
+ dest.getMiddlewares = function() {
+ return middlewares.slice();
+ };
+
+ dest.add = function(middleware) {
+ if (typeof middleware !== 'function')
+ throw new Error('attempted to add non-function middleware');
+
+ // Check for identical object references - bug check.
+ if (middlewares.indexOf(middleware) !== -1)
+ throw new Error('middleware is already registered');
+ middlewares.push(middleware);
+ };
+
+ // fn is the callback to be run once all middlewares have been applied.
+ return function applyMiddlewares(run, facade, callback) {
+ if (typeof facade !== 'object')
+ throw new Error('applyMiddlewares requires a payload object');
+ if (typeof callback !== 'function')
+ throw new Error('applyMiddlewares requires a function callback');
+
+ // Attach callback to the end of the chain.
+ var middlewaresToApply = middlewares.slice();
+ middlewaresToApply.push(callback);
+ executeChain(run, facade, middlewaresToApply, 0);
+ };
+}
+
+// Go over all middlewares until all have been applied.
+function executeChain(run, payload, middlewares, index) {
+ // If the facade has been nullified, immediately skip to the final middleware.
+ if (payload === null) {
+ middlewares[middlewares.length - 1](null);
+ return;
+ }
+
+ // Check if the payload is still a Facade. If not, convert it to one.
+ if (!(payload instanceof Facade)) {
+ payload = new Facade(payload);
+ }
+
+ var mw = middlewares[index];
+ if (mw) {
+ // If there's another middleware, continue down the chain. Otherwise, call the final function.
+ if (middlewares[index + 1]) {
+ run(mw, payload, function(result) {
+ executeChain(run, result, middlewares, ++index);
+ });
+ } else {
+ mw(payload);
+ }
+ }
+}
+
+module.exports.middlewareChain = middlewareChain;
+
+},{"segmentio-facade":86}],23:[function(require,module,exports){
+'use strict';
+
+/**
+ * Module Dependencies.
+ */
+
+var debug = require('debug')('analytics.js:normalize');
+var defaults = require('@ndhoule/defaults');
+var each = require('@ndhoule/each');
+var includes = require('@ndhoule/includes');
+var map = require('@ndhoule/map');
+var type = require('component-type');
+var uuid = require('uuid').v4;
+var json = require('json3');
+var md5 = require('spark-md5').hash;
+
+/**
+ * HOP.
+ */
+
+var has = Object.prototype.hasOwnProperty;
+
+/**
+ * Expose `normalize`
+ */
+
+module.exports = normalize;
+
+/**
+ * Toplevel properties.
+ */
+
+var toplevel = ['integrations', 'anonymousId', 'timestamp', 'context'];
+
+/**
+ * Normalize `msg` based on integrations `list`.
+ *
+ * @param {Object} msg
+ * @param {Array} list
+ * @return {Function}
+ */
+
+function normalize(msg, list) {
+ var lower = map(function(s) {
+ return s.toLowerCase();
+ }, list);
+ var opts = msg.options || {};
+ var integrations = opts.integrations || {};
+ var providers = opts.providers || {};
+ var context = opts.context || {};
+ var ret = {};
+ debug('<-', msg);
+
+ // integrations.
+ each(function(value, key) {
+ if (!integration(key)) return;
+ if (!has.call(integrations, key)) integrations[key] = value;
+ delete opts[key];
+ }, opts);
+
+ // providers.
+ delete opts.providers;
+ each(function(value, key) {
+ if (!integration(key)) return;
+ if (type(integrations[key]) === 'object') return;
+ if (has.call(integrations, key) && typeof providers[key] === 'boolean')
+ return;
+ integrations[key] = value;
+ }, providers);
+
+ // move all toplevel options to msg
+ // and the rest to context.
+ each(function(value, key) {
+ if (includes(key, toplevel)) {
+ ret[key] = opts[key];
+ } else {
+ context[key] = opts[key];
+ }
+ }, opts);
+
+ // generate and attach a messageId to msg
+ msg.messageId = 'ajs-' + md5(json.stringify(msg) + uuid());
+
+ // cleanup
+ delete msg.options;
+ ret.integrations = integrations;
+ ret.context = context;
+ ret = defaults(ret, msg);
+ debug('->', ret);
+ return ret;
+
+ function integration(name) {
+ return !!(
+ includes(name, list) ||
+ name.toLowerCase() === 'all' ||
+ includes(name.toLowerCase(), lower)
+ );
+ }
+}
+
+},{"@ndhoule/defaults":4,"@ndhoule/each":6,"@ndhoule/includes":10,"@ndhoule/map":12,"component-type":57,"debug":27,"json3":67,"spark-md5":93,"uuid":101}],24:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var canonical = require('@segment/canonical');
+var includes = require('@ndhoule/includes');
+var url = require('component-url');
+
+/**
+ * Return a default `options.context.page` object.
+ *
+ * https://segment.com/docs/spec/page/#properties
+ *
+ * @return {Object}
+ */
+
+function pageDefaults() {
+ return {
+ path: canonicalPath(),
+ referrer: document.referrer,
+ search: location.search,
+ title: document.title,
+ url: canonicalUrl(location.search)
+ };
+}
+
+/**
+ * Return the canonical path for the page.
+ *
+ * @return {string}
+ */
+
+function canonicalPath() {
+ var canon = canonical();
+ if (!canon) return window.location.pathname;
+ var parsed = url.parse(canon);
+ return parsed.pathname;
+}
+
+/**
+ * Return the canonical URL for the page concat the given `search`
+ * and strip the hash.
+ *
+ * @param {string} search
+ * @return {string}
+ */
+
+function canonicalUrl(search) {
+ var canon = canonical();
+ if (canon) return includes('?', canon) ? canon : canon + search;
+ var url = window.location.href;
+ var i = url.indexOf('#');
+ return i === -1 ? url : url.slice(0, i);
+}
+
+/*
+ * Exports.
+ */
+
+module.exports = pageDefaults;
+
+},{"@ndhoule/includes":10,"@segment/canonical":33,"component-url":58}],25:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var bindAll = require('bind-all');
+var defaults = require('@ndhoule/defaults');
+var store = require('@segment/store');
+
+/**
+ * Initialize a new `Store` with `options`.
+ *
+ * @param {Object} options
+ */
+
+function Store(options) {
+ this.options(options);
+}
+
+/**
+ * Set the `options` for the store.
+ *
+ * @param {Object} options
+ * @field {Boolean} enabled (true)
+ */
+
+Store.prototype.options = function(options) {
+ if (arguments.length === 0) return this._options;
+
+ options = options || {};
+ defaults(options, { enabled: true });
+
+ this.enabled = options.enabled && store.enabled;
+ this._options = options;
+};
+
+/**
+ * Set a `key` and `value` in local storage.
+ *
+ * @param {string} key
+ * @param {Object} value
+ */
+
+Store.prototype.set = function(key, value) {
+ if (!this.enabled) return false;
+ return store.set(key, value);
+};
+
+/**
+ * Get a value from local storage by `key`.
+ *
+ * @param {string} key
+ * @return {Object}
+ */
+
+Store.prototype.get = function(key) {
+ if (!this.enabled) return null;
+ return store.get(key);
+};
+
+/**
+ * Remove a value from local storage by `key`.
+ *
+ * @param {string} key
+ */
+
+Store.prototype.remove = function(key) {
+ if (!this.enabled) return false;
+ return store.remove(key);
+};
+
+/**
+ * Expose the store singleton.
+ */
+
+module.exports = bindAll(new Store());
+
+/**
+ * Expose the `Store` constructor.
+ */
+
+module.exports.Store = Store;
+
+},{"@ndhoule/defaults":4,"@segment/store":41,"bind-all":44}],26:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var Entity = require('./entity');
+var bindAll = require('bind-all');
+var cookie = require('./cookie');
+var debug = require('debug')('analytics:user');
+var inherit = require('inherits');
+var rawCookie = require('component-cookie');
+var uuid = require('uuid');
+var localStorage = require('./store');
+
+/**
+ * User defaults
+ */
+
+User.defaults = {
+ persist: true,
+ cookie: {
+ key: 'ajs_user_id',
+ oldKey: 'ajs_user'
+ },
+ localStorage: {
+ key: 'ajs_user_traits'
+ }
+};
+
+/**
+ * Initialize a new `User` with `options`.
+ *
+ * @param {Object} options
+ */
+
+function User(options) {
+ this.defaults = User.defaults;
+ this.debug = debug;
+ Entity.call(this, options);
+}
+
+/**
+ * Inherit `Entity`
+ */
+
+inherit(User, Entity);
+
+/**
+ * Set/get the user id.
+ *
+ * When the user id changes, the method will reset his anonymousId to a new one.
+ *
+ * // FIXME: What are the mixed types?
+ * @param {string} id
+ * @return {Mixed}
+ * @example
+ * // didn't change because the user didn't have previous id.
+ * anonymousId = user.anonymousId();
+ * user.id('foo');
+ * assert.equal(anonymousId, user.anonymousId());
+ *
+ * // didn't change because the user id changed to null.
+ * anonymousId = user.anonymousId();
+ * user.id('foo');
+ * user.id(null);
+ * assert.equal(anonymousId, user.anonymousId());
+ *
+ * // change because the user had previous id.
+ * anonymousId = user.anonymousId();
+ * user.id('foo');
+ * user.id('baz'); // triggers change
+ * user.id('baz'); // no change
+ * assert.notEqual(anonymousId, user.anonymousId());
+ */
+
+User.prototype.id = function(id) {
+ var prev = this._getId();
+ var ret = Entity.prototype.id.apply(this, arguments);
+ if (prev == null) return ret;
+ // FIXME: We're relying on coercion here (1 == "1"), but our API treats these
+ // two values differently. Figure out what will break if we remove this and
+ // change to strict equality
+ /* eslint-disable eqeqeq */
+ if (prev != id && id) this.anonymousId(null);
+ /* eslint-enable eqeqeq */
+ return ret;
+};
+
+/**
+ * Set / get / remove anonymousId.
+ *
+ * @param {String} anonymousId
+ * @return {String|User}
+ */
+
+User.prototype.anonymousId = function(anonymousId) {
+ var store = this.storage();
+
+ // set / remove
+ if (arguments.length) {
+ store.set('ajs_anonymous_id', anonymousId);
+ this._setAnonymousIdInLocalStorage(anonymousId);
+ return this;
+ }
+
+ // new
+ anonymousId = store.get('ajs_anonymous_id');
+ if (anonymousId) {
+ // value exists in cookie, copy it to localStorage
+ this._setAnonymousIdInLocalStorage(anonymousId);
+ // refresh cookie to extend expiry
+ store.set('ajs_anonymous_id', anonymousId);
+ return anonymousId;
+ }
+
+ if (!this._options.localStorageFallbackDisabled) {
+ // if anonymousId doesn't exist in cookies, check localStorage
+ anonymousId = localStorage.get('ajs_anonymous_id');
+ if (anonymousId) {
+ // Write to cookies if available in localStorage but not cookies
+ store.set('ajs_anonymous_id', anonymousId);
+ return anonymousId;
+ }
+ }
+
+ // old - it is not stringified so we use the raw cookie.
+ anonymousId = rawCookie('_sio');
+ if (anonymousId) {
+ anonymousId = anonymousId.split('----')[0];
+ store.set('ajs_anonymous_id', anonymousId);
+ this._setAnonymousIdInLocalStorage(anonymousId);
+ store.remove('_sio');
+ return anonymousId;
+ }
+
+ // empty
+ anonymousId = uuid.v4();
+ store.set('ajs_anonymous_id', anonymousId);
+ this._setAnonymousIdInLocalStorage(anonymousId);
+ return store.get('ajs_anonymous_id');
+};
+
+/**
+ * Set the user's `anonymousid` in local storage.
+ *
+ * @param {String} id
+ */
+
+User.prototype._setAnonymousIdInLocalStorage = function(id) {
+ if (!this._options.localStorageFallbackDisabled) {
+ localStorage.set('ajs_anonymous_id', id);
+ }
+};
+
+/**
+ * Remove anonymous id on logout too.
+ */
+
+User.prototype.logout = function() {
+ Entity.prototype.logout.call(this);
+ this.anonymousId(null);
+};
+
+/**
+ * Load saved user `id` or `traits` from storage.
+ */
+
+User.prototype.load = function() {
+ if (this._loadOldCookie()) return;
+ Entity.prototype.load.call(this);
+};
+
+/**
+ * BACKWARDS COMPATIBILITY: Load the old user from the cookie.
+ *
+ * @api private
+ * @return {boolean}
+ */
+
+User.prototype._loadOldCookie = function() {
+ var user = cookie.get(this._options.cookie.oldKey);
+ if (!user) return false;
+
+ this.id(user.id);
+ this.traits(user.traits);
+ cookie.remove(this._options.cookie.oldKey);
+ return true;
+};
+
+/**
+ * Expose the user singleton.
+ */
+
+module.exports = bindAll(new User());
+
+/**
+ * Expose the `User` constructor.
+ */
+
+module.exports.User = User;
+
+},{"./cookie":16,"./entity":17,"./store":25,"bind-all":44,"component-cookie":46,"debug":27,"inherits":64,"uuid":101}],27:[function(require,module,exports){
+
+/**
+ * Expose `debug()` as the module.
+ */
+
+module.exports = debug;
+
+/**
+ * Create a debugger with the given `name`.
+ *
+ * @param {String} name
+ * @return {Type}
+ * @api public
+ */
+
+function debug(name) {
+ if (!debug.enabled(name)) return function(){};
+
+ return function(fmt){
+ fmt = coerce(fmt);
+
+ var curr = new Date;
+ var ms = curr - (debug[name] || curr);
+ debug[name] = curr;
+
+ fmt = name
+ + ' '
+ + fmt
+ + ' +' + debug.humanize(ms);
+
+ // This hackery is required for IE8
+ // where `console.log` doesn't have 'apply'
+ window.console
+ && console.log
+ && Function.prototype.apply.call(console.log, console, arguments);
+ }
+}
+
+/**
+ * The currently active debug mode names.
+ */
+
+debug.names = [];
+debug.skips = [];
+
+/**
+ * Enables a debug mode by name. This can include modes
+ * separated by a colon and wildcards.
+ *
+ * @param {String} name
+ * @api public
+ */
+
+debug.enable = function(name) {
+ try {
+ localStorage.debug = name;
+ } catch(e){}
+
+ var split = (name || '').split(/[\s,]+/)
+ , len = split.length;
+
+ for (var i = 0; i < len; i++) {
+ name = split[i].replace('*', '.*?');
+ if (name[0] === '-') {
+ debug.skips.push(new RegExp('^' + name.substr(1) + '$'));
+ }
+ else {
+ debug.names.push(new RegExp('^' + name + '$'));
+ }
+ }
+};
+
+/**
+ * Disable debug output.
+ *
+ * @api public
+ */
+
+debug.disable = function(){
+ debug.enable('');
+};
+
+/**
+ * Humanize the given `ms`.
+ *
+ * @param {Number} m
+ * @return {String}
+ * @api private
+ */
+
+debug.humanize = function(ms) {
+ var sec = 1000
+ , min = 60 * 1000
+ , hour = 60 * min;
+
+ if (ms >= hour) return (ms / hour).toFixed(1) + 'h';
+ if (ms >= min) return (ms / min).toFixed(1) + 'm';
+ if (ms >= sec) return (ms / sec | 0) + 's';
+ return ms + 'ms';
+};
+
+/**
+ * Returns true if the given mode name is enabled, false otherwise.
+ *
+ * @param {String} name
+ * @return {Boolean}
+ * @api public
+ */
+
+debug.enabled = function(name) {
+ for (var i = 0, len = debug.skips.length; i < len; i++) {
+ if (debug.skips[i].test(name)) {
+ return false;
+ }
+ }
+ for (var i = 0, len = debug.names.length; i < len; i++) {
+ if (debug.names[i].test(name)) {
+ return true;
+ }
+ }
+ return false;
+};
+
+/**
+ * Coerce `val`.
+ */
+
+function coerce(val) {
+ if (val instanceof Error) return val.stack || val.message;
+ return val;
+}
+
+// persist
+
+try {
+ if (window.localStorage) debug.enable(localStorage.debug);
+} catch(e){}
+
+},{}],28:[function(require,module,exports){
+module.exports={
+ "name": "@segment/analytics.js-core",
+ "author": "Segment <fr...@segment.com>",
+ "version": "3.10.1",
+ "description": "The hassle-free way to integrate analytics into any web application.",
+ "keywords": [
+ "analytics",
+ "analytics.js",
+ "segment",
+ "segment.io"
+ ],
+ "main": "lib/index.js",
+ "scripts": {
+ "test": "make test",
+ "lint": "eslint \"./{lib,test}/**/*.js\"",
+ "format": "prettier-eslint --write --list-different \"./{lib,test}/**/*.{js,json,md}\"",
+ "precommit": "lint-staged",
+ "np": "np --no-publish",
+ "cz": "git-cz",
+ "commitmsg": "commitlint -E GIT_PARAMS"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/segmentio/analytics.js-core"
+ },
+ "license": "SEE LICENSE IN LICENSE",
+ "bugs": {
+ "url": "https://github.com/segmentio/analytics.js-core/issues"
+ },
+ "homepage": "https://github.com/segmentio/analytics.js-core#readme",
+ "dependencies": {
+ "@ndhoule/clone": "^1.0.0",
+ "@ndhoule/defaults": "^2.0.1",
+ "@ndhoule/each": "^2.0.1",
+ "@ndhoule/extend": "^2.0.0",
+ "@ndhoule/foldl": "^2.0.1",
+ "@ndhoule/includes": "^2.0.1",
+ "@ndhoule/keys": "^2.0.0",
+ "@ndhoule/map": "^2.0.1",
+ "@ndhoule/pick": "^2.0.0",
+ "@segment/canonical": "^1.0.0",
+ "@segment/is-meta": "^1.0.0",
+ "@segment/isodate": "^1.0.2",
+ "@segment/isodate-traverse": "^1.0.1",
+ "@segment/prevent-default": "^1.0.0",
+ "@segment/send-json": "^3.0.0",
+ "@segment/store": "^1.3.20",
+ "@segment/top-domain": "^3.0.0",
+ "bind-all": "^1.0.0",
+ "component-cookie": "^1.1.2",
+ "component-emitter": "^1.2.1",
+ "component-event": "^0.1.4",
+ "component-querystring": "^2.0.0",
+ "component-type": "^1.2.1",
+ "component-url": "^0.2.1",
+ "debug": "^0.7.4",
+ "extend": "3.0.2",
+ "inherits": "^2.0.1",
+ "install": "^0.7.3",
+ "is": "^3.1.0",
+ "json3": "^3.3.2",
+ "new-date": "^1.0.0",
+ "next-tick": "^0.2.2",
+ "segmentio-facade": "^3.0.2",
+ "spark-md5": "^2.0.2",
+ "uuid": "^2.0.2"
+ },
+ "devDependencies": {
+ "@commitlint/cli": "^7.0.0",
+ "@commitlint/config-conventional": "^7.0.1",
+ "@segment/analytics.js-integration": "^3.2.1",
+ "@segment/eslint-config": "^4.0.0",
+ "browserify": "13.0.0",
+ "browserify-istanbul": "^2.0.0",
+ "codecov": "^3.0.2",
+ "commitizen": "^2.10.1",
+ "commitlint-circle": "^1.0.0",
+ "compat-trigger-event": "^1.0.0",
+ "component-each": "^0.2.6",
+ "cz-conventional-changelog": "^2.1.0",
+ "eslint": "^4.19.1",
+ "eslint-config-prettier": "^2.9.0",
+ "eslint-plugin-mocha": "^5.0.0",
+ "eslint-plugin-react": "^7.9.1",
+ "eslint-plugin-require-path-exists": "^1.1.8",
+ "husky": "^0.14.3",
+ "istanbul": "^0.4.3",
+ "jquery": "^3.2.1",
+ "karma": "1.3.0",
+ "karma-browserify": "^5.0.4",
+ "karma-chrome-launcher": "^1.0.1",
+ "karma-coverage": "^1.0.0",
+ "karma-junit-reporter": "^1.0.0",
+ "karma-mocha": "1.0.1",
+ "karma-phantomjs-launcher": "^1.0.0",
+ "karma-sauce-launcher": "^1.0.0",
+ "karma-spec-reporter": "0.0.26",
+ "karma-summary-reporter": "^1.5.0",
+ "lint-staged": "^7.2.0",
+ "mocha": "^2.2.5",
+ "np": "^3.0.4",
+ "phantomjs-prebuilt": "^2.1.7",
+ "prettier-eslint-cli": "^4.7.1",
+ "proclaim": "^3.4.1",
+ "sinon": "^1.7.3",
+ "snyk": "^1.83.0",
+ "watchify": "^3.7.0"
+ },
+ "commitlint": {
+ "extends": [
+ "@commitlint/config-conventional"
+ ]
+ },
+ "lint-staged": {
+ "linters": {
+ "*.{js,json,md}": [
+ "prettier-eslint --write",
+ "git add"
+ ]
+ }
+ },
+ "config": {
+ "commitizen": {
+ "path": "cz-conventional-changelog"
+ }
+ }
+}
+
+},{}],29:[function(require,module,exports){
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+var bind = require('component-bind');
+var cloneDeep = require('lodash.clonedeep');
+var debug = require('debug');
+var defaults = require('@ndhoule/defaults');
+var extend = require('@ndhoule/extend');
+var slug = require('slug-component');
+var protos = require('./protos');
+var statics = require('./statics');
+
+/**
+ * Create a new `Integration` constructor.
+ *
+ * @constructs Integration
+ * @param {string} name
+ * @return {Function} Integration
+ */
+
+function createIntegration(name) {
+ /**
+ * Initialize a new `Integration`.
+ *
+ * @class
+ * @param {Object} options
+ */
+
+ function Integration(options) {
+ if (options && options.addIntegration) {
+ // plugin
+ return options.addIntegration(Integration);
+ }
+ this.debug = debug('analytics:integration:' + slug(name));
+ this.options = defaults(cloneDeep(options) || {}, this.defaults);
+ this._queue = [];
+ this.once('ready', bind(this, this.flush));
+
+ Integration.emit('construct', this);
+ this.ready = bind(this, this.ready);
+ this._wrapInitialize();
+ this._wrapPage();
+ this._wrapTrack();
+ }
+
+ Integration.prototype.defaults = {};
+ Integration.prototype.globals = [];
+ Integration.prototype.templates = {};
+ Integration.prototype.name = name;
+ extend(Integration, statics);
+ extend(Integration.prototype, protos);
+
+ return Integration;
+}
+
+/**
+ * Exports.
+ */
+
+module.exports = createIntegration;
+
+},{"./protos":30,"./statics":31,"@ndhoule/defaults":4,"@ndhoule/extend":8,"component-bind":45,"debug":59,"lodash.clonedeep":70,"slug-component":92}],30:[function(require,module,exports){
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+var Emitter = require('component-emitter');
+var after = require('@ndhoule/after');
+var each = require('@ndhoule/each');
+var events = require('analytics-events');
+var every = require('@ndhoule/every');
+var fmt = require('@segment/fmt');
+var foldl = require('@ndhoule/foldl');
+var is = require('is');
+var loadIframe = require('load-iframe');
+var loadScript = require('@segment/load-script');
+var nextTick = require('next-tick');
+var normalize = require('to-no-case');
+
+/**
+ * hasOwnProperty reference.
+ */
+
+var has = Object.prototype.hasOwnProperty;
+
+/**
+ * No operation.
+ */
+
+var noop = function noop() {};
+
+/**
+ * Window defaults.
+ */
+
+var onerror = window.onerror;
+var onload = null;
+
+/**
+ * Mixin emitter.
+ */
+
+/* eslint-disable new-cap */
+Emitter(exports);
+/* eslint-enable new-cap */
+
+/**
+ * Initialize.
+ */
+
+exports.initialize = function() {
+ var ready = this.ready;
+ nextTick(ready);
+};
+
+/**
+ * Loaded?
+ *
+ * @api private
+ * @return {boolean}
+ */
+
+exports.loaded = function() {
+ return false;
+};
+
+/**
+ * Page.
+ *
+ * @api public
+ * @param {Page} page
+ */
+
+/* eslint-disable no-unused-vars */
+exports.page = function(page) {};
+/* eslint-enable no-unused-vars */
+
+/**
+ * Track.
+ *
+ * @api public
+ * @param {Track} track
+ */
+
+/* eslint-disable no-unused-vars */
+exports.track = function(track) {};
+/* eslint-enable no-unused-vars */
+
+/**
+ * Get values from items in `options` that are mapped to `key`.
+ * `options` is an integration setting which is a collection
+ * of type 'map', 'array', or 'mixed'
+ *
+ * Use cases include mapping events to pixelIds (map), sending generic
+ * conversion pixels only for specific events (array), or configuring dynamic
+ * mappings of event properties to query string parameters based on event (mixed)
+ *
+ * @api public
+ * @param {Object|Object[]|String[]} options An object, array of objects, or
+ * array of strings pulled from settings.mapping.
+ * @param {string} key The name of the item in options whose metadata
+ * we're looking for.
+ * @return {Array} An array of settings that match the input `key` name.
+ * @example
+ *
+ * // 'Map'
+ * var events = { my_event: 'a4991b88' };
+ * .map(events, 'My Event');
+ * // => ["a4991b88"]
+ * .map(events, 'whatever');
+ * // => []
+ *
+ * // 'Array'
+ * * var events = ['Completed Order', 'My Event'];
+ * .map(events, 'My Event');
+ * // => ["My Event"]
+ * .map(events, 'whatever');
+ * // => []
+ *
+ * // 'Mixed'
+ * var events = [{ key: 'my event', value: '9b5eb1fa' }];
+ * .map(events, 'my_event');
+ * // => ["9b5eb1fa"]
+ * .map(events, 'whatever');
+ * // => []
+ */
+
+exports.map = function(options, key) {
+ var normalizedComparator = normalize(key);
+ var mappingType = getMappingType(options);
+
+ if (mappingType === 'unknown') {
+ return [];
+ }
+
+ return foldl(function(matchingValues, val, key) {
+ var compare;
+ var result;
+
+ if (mappingType === 'map') {
+ compare = key;
+ result = val;
+ }
+
+ if (mappingType === 'array') {
+ compare = val;
+ result = val;
+ }
+
+ if (mappingType === 'mixed') {
+ compare = val.key;
+ result = val.value;
+ }
+
+ if (normalize(compare) === normalizedComparator) {
+ matchingValues.push(result);
+ }
+
+ return matchingValues;
+ }, [], options);
+};
+
+/**
+ * Invoke a `method` that may or may not exist on the prototype with `args`,
+ * queueing or not depending on whether the integration is "ready". Don't
+ * trust the method call, since it contains integration party code.
+ *
+ * @api private
+ * @param {string} method
+ * @param {...*} args
+ */
+
+exports.invoke = function(method) {
+ if (!this[method]) return;
+ var args = Array.prototype.slice.call(arguments, 1);
+ if (!this._ready) return this.queue(method, args);
+ var ret;
+
+ try {
+ this.debug('%s with %o', method, args);
+ ret = this[method].apply(this, args);
+ } catch (e) {
+ this.debug('error %o calling %s with %o', e, method, args);
+ }
+
+ return ret;
+};
+
+/**
+ * Queue a `method` with `args`.
+ *
+ * @api private
+ * @param {string} method
+ * @param {Array} args
+ */
+
+exports.queue = function(method, args) {
+ this._queue.push({ method: method, args: args });
+};
+
+/**
+ * Flush the internal queue.
+ *
+ * @api private
+ */
+
+exports.flush = function() {
+ this._ready = true;
+ var self = this;
+
+ each(function(call) {
+ self[call.method].apply(self, call.args);
+ }, this._queue);
+
+ // Empty the queue.
+ this._queue.length = 0;
+};
+
+/**
+ * Reset the integration, removing its global variables.
+ *
+ * @api private
+ */
+
+exports.reset = function() {
+ for (var i = 0; i < this.globals.length; i++) {
+ window[this.globals[i]] = undefined;
+ }
+
+ window.onerror = onerror;
+ window.onload = onload;
+};
+
+/**
+ * Load a tag by `name`.
+ *
+ * @param {string} name The name of the tag.
+ * @param {Object} locals Locals used to populate the tag's template variables
+ * (e.g. `userId` in '<img src="https://whatever.com/{{ userId }}">').
+ * @param {Function} [callback=noop] A callback, invoked when the tag finishes
+ * loading.
+ */
+
+exports.load = function(name, locals, callback) {
+ // Argument shuffling
+ if (typeof name === 'function') { callback = name; locals = null; name = null; }
+ if (name && typeof name === 'object') { callback = locals; locals = name; name = null; }
+ if (typeof locals === 'function') { callback = locals; locals = null; }
+
+ // Default arguments
+ name = name || 'library';
+ locals = locals || {};
+
+ locals = this.locals(locals);
+ var template = this.templates[name];
+ if (!template) throw new Error(fmt('template "%s" not defined.', name));
+ var attrs = render(template, locals);
+ callback = callback || noop;
+ var self = this;
+ var el;
+
+ switch (template.type) {
+ case 'img':
+ attrs.width = 1;
+ attrs.height = 1;
+ el = loadImage(attrs, callback);
+ break;
+ case 'script':
+ el = loadScript(attrs, function(err) {
+ if (!err) return callback();
+ self.debug('error loading "%s" error="%s"', self.name, err);
+ });
+ // TODO: hack until refactoring load-script
+ delete attrs.src;
+ each(function(val, key) {
+ el.setAttribute(key, val);
+ }, attrs);
+ break;
+ case 'iframe':
+ el = loadIframe(attrs, callback);
+ break;
+ default:
+ // No default case
+ }
+
+ return el;
+};
+
+/**
+ * Locals for tag templates.
+ *
+ * By default it includes a cache buster and all of the options.
+ *
+ * @param {Object} [locals]
+ * @return {Object}
+ */
+
+exports.locals = function(locals) {
+ locals = locals || {};
+ var cache = Math.floor(new Date().getTime() / 3600000);
+ if (!locals.hasOwnProperty('cache')) locals.cache = cache;
+ each(function(val, key) {
+ if (!locals.hasOwnProperty(key)) locals[key] = val;
+ }, this.options);
+ return locals;
+};
+
+/**
+ * Simple way to emit ready.
+ *
+ * @api public
+ */
+
+exports.ready = function() {
+ this.emit('ready');
+};
+
+/**
+ * Wrap the initialize method in an exists check, so we don't have to do it for
+ * every single integration.
+ *
+ * @api private
+ */
+
+exports._wrapInitialize = function() {
+ var initialize = this.initialize;
+ this.initialize = function() {
+ this.debug('initialize');
+ this._initialized = true;
+ var ret = initialize.apply(this, arguments);
+ this.emit('initialize');
+ return ret;
+ };
+};
+
+/**
+ * Wrap the page method to call to noop the first page call if the integration assumes
+ * a pageview.
+ *
+ * @api private
+ */
+
+exports._wrapPage = function() {
+ // Noop the first page call if integration assumes pageview
+ if (this._assumesPageview) return this.page = after(2, this.page);
+};
+
+/**
+ * Wrap the track method to call other ecommerce methods if available depending
+ * on the `track.event()`.
+ *
+ * @api private
+ */
+
+exports._wrapTrack = function() {
+ var t = this.track;
+ this.track = function(track) {
+ var event = track.event();
+ var called;
+ var ret;
+
+ for (var method in events) {
+ if (has.call(events, method)) {
+ var regexp = events[method];
+ if (!this[method]) continue;
+ if (!regexp.test(event)) continue;
+ ret = this[method].apply(this, arguments);
+ called = true;
+ break;
+ }
+ }
+
+ if (!called) ret = t.apply(this, arguments);
+ return ret;
+ };
+};
+
+/**
+ * Determine the type of the option passed to `#map`
+ *
+ * @api private
+ * @param {Object|Object[]} mapping
+ * @return {String} mappingType
+ */
+
+function getMappingType(mapping) {
+ if (is.array(mapping)) {
+ return every(isMixed, mapping) ? 'mixed' : 'array';
+ }
+ if (is.object(mapping)) return 'map';
+ return 'unknown';
+}
+
+/**
+ * Determine if item in mapping array is a valid "mixed" type value
+ *
+ * Must be an object with properties "key" (of type string)
+ * and "value" (of any type)
+ *
+ * @api private
+ * @param {*} item
+ * @return {Boolean}
+ */
+
+function isMixed(item) {
+ if (!is.object(item)) return false;
+ if (!is.string(item.key)) return false;
+ if (!has.call(item, 'value')) return false;
+ return true;
+}
+
+/**
+ * TODO: Document me
+ *
+ * @api private
+ * @param {Object} attrs
+ * @param {Function} fn
+ * @return {Image}
+ */
+
+function loadImage(attrs, fn) {
+ fn = fn || function() {};
+ var img = new Image();
+ img.onerror = error(fn, 'failed to load pixel', img);
+ img.onload = function() { fn(); };
+ img.src = attrs.src;
+ img.width = 1;
+ img.height = 1;
+ return img;
+}
+
+/**
+ * TODO: Document me
+ *
+ * @api private
+ * @param {Function} fn
+ * @param {string} message
+ * @param {Element} img
+ * @return {Function}
+ */
+
+function error(fn, message, img) {
+ return function(e) {
+ e = e || window.event;
+ var err = new Error(message);
+ err.event = e;
+ err.source = img;
+ fn(err);
+ };
+}
+
+/**
+ * Render template + locals into an `attrs` object.
+ *
+ * @api private
+ * @param {Object} template
+ * @param {Object} locals
+ * @return {Object}
+ */
+
+function render(template, locals) {
+ return foldl(function(attrs, val, key) {
+ attrs[key] = val.replace(/\{\{\ *(\w+)\ *\}\}/g, function(_, $1) {
+ return locals[$1];
+ });
+ return attrs;
+ }, {}, template.attrs);
+}
+
+},{"@ndhoule/after":1,"@ndhoule/each":6,"@ndhoule/every":7,"@ndhoule/foldl":9,"@segment/fmt":34,"@segment/load-script":38,"analytics-events":43,"component-emitter":52,"is":66,"load-iframe":69,"next-tick":76,"to-no-case":96}],31:[function(require,module,exports){
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+var Emitter = require('component-emitter');
+var domify = require('domify');
+var each = require('@ndhoule/each');
+var includes = require('@ndhoule/includes');
+
+/**
+ * Mix in emitter.
+ */
+
+/* eslint-disable new-cap */
+Emitter(exports);
+/* eslint-enable new-cap */
+
+/**
+ * Add a new option to the integration by `key` with default `value`.
+ *
+ * @api public
+ * @param {string} key
+ * @param {*} value
+ * @return {Integration}
+ */
+
+exports.option = function(key, value) {
+ this.prototype.defaults[key] = value;
+ return this;
+};
+
+/**
+ * Add a new mapping option.
+ *
+ * This will create a method `name` that will return a mapping for you to use.
+ *
+ * @api public
+ * @param {string} name
+ * @return {Integration}
+ * @example
+ * Integration('My Integration')
+ * .mapping('events');
+ *
+ * new MyIntegration().track('My Event');
+ *
+ * .track = function(track){
+ * var events = this.events(track.event());
+ * each(send, events);
+ * };
+ */
+
+exports.mapping = function(name) {
+ this.option(name, []);
+ this.prototype[name] = function(key) {
+ return this.map(this.options[name], key);
+ };
+ return this;
+};
+
+/**
+ * Register a new global variable `key` owned by the integration, which will be
+ * used to test whether the integration is already on the page.
+ *
+ * @api public
+ * @param {string} key
+ * @return {Integration}
+ */
+
+exports.global = function(key) {
+ this.prototype.globals.push(key);
+ return this;
+};
+
+/**
+ * Mark the integration as assuming an initial pageview, so to defer the first page call, keep track of
+ * whether we already nooped the first page call.
+ *
+ * @api public
+ * @return {Integration}
+ */
+
+exports.assumesPageview = function() {
+ this.prototype._assumesPageview = true;
+ return this;
+};
+
+/**
+ * Mark the integration as being "ready" once `load` is called.
+ *
+ * @api public
+ * @return {Integration}
+ */
+
+exports.readyOnLoad = function() {
+ this.prototype._readyOnLoad = true;
+ return this;
+};
+
+/**
+ * Mark the integration as being "ready" once `initialize` is called.
+ *
+ * @api public
+ * @return {Integration}
+ */
+
+exports.readyOnInitialize = function() {
+ this.prototype._readyOnInitialize = true;
+ return this;
+};
+
+/**
+ * Define a tag to be loaded.
+ *
+ * @api public
+ * @param {string} [name='library'] A nicename for the tag, commonly used in
+ * #load. Helpful when the integration has multiple tags and you need a way to
+ * specify which of the tags you want to load at a given time.
+ * @param {String} str DOM tag as string or URL.
+ * @return {Integration}
+ */
+
+exports.tag = function(name, tag) {
+ if (tag == null) {
+ tag = name;
+ name = 'library';
+ }
+ this.prototype.templates[name] = objectify(tag);
+ return this;
+};
+
+/**
+ * Given a string, give back DOM attributes.
+ *
+ * Do it in a way where the browser doesn't load images or iframes. It turns
+ * out domify will load images/iframes because whenever you construct those
+ * DOM elements, the browser immediately loads them.
+ *
+ * @api private
+ * @param {string} str
+ * @return {Object}
+ */
+
+function objectify(str) {
+ // replace `src` with `data-src` to prevent image loading
+ str = str.replace(' src="', ' data-src="');
+
+ var el = domify(str);
+ var attrs = {};
+
+ each(function(attr) {
+ // then replace it back
+ var name = attr.name === 'data-src' ? 'src' : attr.name;
+ if (!includes(attr.name + '=', str)) return;
+ attrs[name] = attr.value;
+ }, el.attributes);
+
+ return {
+ type: el.tagName.toLowerCase(),
+ attrs: attrs
+ };
+}
+
+},{"@ndhoule/each":6,"@ndhoule/includes":10,"component-emitter":52,"domify":61}],32:[function(require,module,exports){
+var utf8Encode = require('utf8-encode');
+var keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+
+module.exports = encode;
+function encode(input) {
+ var output = "";
+ var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+ var i = 0;
+
+ input = utf8Encode(input);
+
+ while (i < input.length) {
+
+ chr1 = input.charCodeAt(i++);
+ chr2 = input.charCodeAt(i++);
+ chr3 = input.charCodeAt(i++);
+
+ enc1 = chr1 >> 2;
+ enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+ enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+ enc4 = chr3 & 63;
+
+ if (isNaN(chr2)) {
+ enc3 = enc4 = 64;
+ } else if (isNaN(chr3)) {
+ enc4 = 64;
+ }
+
+ output = output +
+ keyStr.charAt(enc1) + keyStr.charAt(enc2) +
+ keyStr.charAt(enc3) + keyStr.charAt(enc4);
+
+ }
+
+ return output;
+}
+},{"utf8-encode":99}],33:[function(require,module,exports){
+'use strict';
+
+/**
+ * Get the current page's canonical URL.
+ *
+ * @return {string|undefined}
+ */
+function canonical() {
+ var tags = document.getElementsByTagName('link');
+ // eslint-disable-next-line no-cond-assign
+ for (var i = 0, tag; tag = tags[i]; i++) {
+ if (tag.getAttribute('rel') === 'canonical') {
+ return tag.getAttribute('href');
+ }
+ }
+}
+
+/*
+ * Exports.
+ */
+
+module.exports = canonical;
+
+},{}],34:[function(require,module,exports){
+(function (global){(function (){
+'use strict';
+
+// Stringifier
+var toString = global.JSON && typeof JSON.stringify === 'function' ? JSON.stringify : String;
+
+/**
+ * Format the given `str`.
+ *
+ * @param {string} str
+ * @param {...*} [args]
+ * @return {string}
+ */
+function fmt(str) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ var j = 0;
+
+ return str.replace(/%([a-z])/gi, function(match, f) {
+ return fmt[f] ? fmt[f](args[j++]) : match + f;
+ });
+}
+
+// Formatters
+fmt.o = toString;
+fmt.s = String;
+fmt.d = parseInt;
+
+/*
+ * Exports.
+ */
+
+module.exports = fmt;
+
+}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],35:[function(require,module,exports){
+'use strict';
+
+function isMeta(e) {
+ if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) {
+ return true;
+ }
+
+ // Logic that handles checks for the middle mouse button, based
+ // on [jQuery](https://github.com/jquery/jquery/blob/master/src/event.js#L466).
+ var which = e.which;
+ var button = e.button;
+ if (!which && button !== undefined) {
+ // eslint-disable-next-line no-bitwise, no-extra-parens
+ return (!button & 1) && (!button & 2) && (button & 4);
+ } else if (which === 2) {
+ return true;
+ }
+
+ return false;
+}
+
+/*
+ * Exports.
+ */
+
+module.exports = isMeta;
+
+},{}],36:[function(require,module,exports){
+'use strict';
+
+var type = require('component-type');
+var each = require('component-each');
+var isodate = require('@segment/isodate');
+
+/**
+ * Expose `traverse`.
+ */
+
+module.exports = traverse;
+
+/**
+ * Traverse an object or array, and return a clone with all ISO strings parsed
+ * into Date objects.
+ *
+ * @param {Object} obj
+ * @return {Object}
+ */
+
+function traverse(input, strict) {
+ if (strict === undefined) strict = true;
+
+ if (type(input) === 'object') return object(input, strict);
+ if (type(input) === 'array') return array(input, strict);
+ return input;
+}
+
+/**
+ * Object traverser.
+ *
+ * @param {Object} obj
+ * @param {Boolean} strict
+ * @return {Object}
+ */
+
+function object(obj, strict) {
+ // 'each' utility uses obj.length to check whether the obj is array. To avoid incorrect classification, wrap call to 'each' with rename of obj.length
+ if (obj.length && typeof obj.length === 'number' && !(obj.length - 1 in obj)) { // cross browser compatible way of checking has length and is not array
+ obj.lengthNonArray = obj.length;
+ delete obj.length;
+ }
+ each(obj, function(key, val) {
+ if (isodate.is(val, strict)) {
+ obj[key] = isodate.parse(val);
+ } else if (type(val) === 'object' || type(val) === 'array') {
+ traverse(val, strict);
+ }
+ });
+ // restore obj.length if it was renamed
+ if (obj.lengthNonArray) {
+ obj.length = obj.lengthNonArray;
+ delete obj.lengthNonArray;
+ }
+ return obj;
+}
+
+/**
+ * Array traverser.
+ *
+ * @param {Array} arr
+ * @param {Boolean} strict
+ * @return {Array}
+ */
+
+function array(arr, strict) {
+ each(arr, function(val, x) {
+ if (type(val) === 'object') {
+ traverse(val, strict);
+ } else if (isodate.is(val, strict)) {
+ arr[x] = isodate.parse(val);
+ }
+ });
+ return arr;
+}
+
+},{"@segment/isodate":37,"component-each":50,"component-type":57}],37:[function(require,module,exports){
+'use strict';
+
+/**
+ * Matcher, slightly modified from:
+ *
+ * https://github.com/csnover/js-iso8601/blob/lax/iso8601.js
+ */
+
+var matcher = /^(\d{4})(?:-?(\d{2})(?:-?(\d{2}))?)?(?:([ T])(\d{2}):?(\d{2})(?::?(\d{2})(?:[,\.](\d{1,}))?)?(?:(Z)|([+\-])(\d{2})(?::?(\d{2}))?)?)?$/;
+
+/**
+ * Convert an ISO date string to a date. Fallback to native `Date.parse`.
+ *
+ * https://github.com/csnover/js-iso8601/blob/lax/iso8601.js
+ *
+ * @param {String} iso
+ * @return {Date}
+ */
+
+exports.parse = function(iso) {
+ var numericKeys = [1, 5, 6, 7, 11, 12];
+ var arr = matcher.exec(iso);
+ var offset = 0;
+
+ // fallback to native parsing
+ if (!arr) {
+ return new Date(iso);
+ }
+
+ /* eslint-disable no-cond-assign */
+ // remove undefined values
+ for (var i = 0, val; val = numericKeys[i]; i++) {
+ arr[val] = parseInt(arr[val], 10) || 0;
+ }
+ /* eslint-enable no-cond-assign */
+
+ // allow undefined days and months
+ arr[2] = parseInt(arr[2], 10) || 1;
+ arr[3] = parseInt(arr[3], 10) || 1;
+
+ // month is 0-11
+ arr[2]--;
+
+ // allow abitrary sub-second precision
+ arr[8] = arr[8] ? (arr[8] + '00').substring(0, 3) : 0;
+
+ // apply timezone if one exists
+ if (arr[4] === ' ') {
+ offset = new Date().getTimezoneOffset();
+ } else if (arr[9] !== 'Z' && arr[10]) {
+ offset = arr[11] * 60 + arr[12];
+ if (arr[10] === '+') {
+ offset = 0 - offset;
+ }
+ }
+
+ var millis = Date.UTC(arr[1], arr[2], arr[3], arr[5], arr[6] + offset, arr[7], arr[8]);
+ return new Date(millis);
+};
+
+
+/**
+ * Checks whether a `string` is an ISO date string. `strict` mode requires that
+ * the date string at least have a year, month and date.
+ *
+ * @param {String} string
+ * @param {Boolean} strict
+ * @return {Boolean}
+ */
+
+exports.is = function(string, strict) {
+ if (typeof string !== 'string') {
+ return false;
+ }
+ if (strict && (/^\d{4}-\d{2}-\d{2}/).test(string) === false) {
+ return false;
+ }
+ return matcher.test(string);
+};
+
+},{}],38:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var onload = require('script-onload');
+var tick = require('next-tick');
+var type = require('component-type');
+
+/**
+ * Loads a script asynchronously.
+ *
+ * @param {Object} options
+ * @param {Function} cb
+ */
+function loadScript(options, cb) {
+ if (!options) {
+ throw new Error('Can\'t load nothing...');
+ }
+
+ // Allow for the simplest case, just passing a `src` string.
+ if (type(options) === 'string') {
+ options = { src : options };
+ }
+
+ var https = document.location.protocol === 'https:' || document.location.protocol === 'chrome-extension:';
+
+ // If you use protocol relative URLs, third-party scripts like Google
+ // Analytics break when testing with `file:` so this fixes that.
+ if (options.src && options.src.indexOf('//') === 0) {
+ options.src = (https ? 'https:' : 'http:') + options.src;
+ }
+
+ // Allow them to pass in different URLs depending on the protocol.
+ if (https && options.https) {
+ options.src = options.https;
+ } else if (!https && options.http) {
+ options.src = options.http;
+ }
+
+ // Make the `<script>` element and insert it before the first script on the
+ // page, which is guaranteed to exist since this Javascript is running.
+ var script = document.createElement('script');
+ script.type = 'text/javascript';
+ script.async = true;
+ script.src = options.src;
+
+ // If we have a cb, attach event handlers. Does not work on < IE9 because
+ // older browser versions don't register element.onerror
+ if (type(cb) === 'function') {
+ onload(script, cb);
+ }
+
+ tick(function() {
+ // Append after event listeners are attached for IE.
+ var firstScript = document.getElementsByTagName('script')[0];
+ firstScript.parentNode.insertBefore(script, firstScript);
+ });
+
+ // Return the script element in case they want to do anything special, like
+ // give it an ID or attributes.
+ return script;
+}
+
+/*
+ * Exports.
+ */
+
+module.exports = loadScript;
+
+},{"component-type":57,"next-tick":76,"script-onload":79}],39:[function(require,module,exports){
+'use strict';
+
+/**
+ * Prevent default on a given event.
+ *
+ * @param {Event} e
+ * @example
+ * anchor.onclick = prevent;
+ * anchor.onclick = function(e){
+ * if (something) return prevent(e);
+ * };
+ */
+
+function preventDefault(e) {
+ e = e || window.event;
+ return e.preventDefault ? e.preventDefault() : e.returnValue = false;
+}
+
+/*
+ * Exports.
+ */
+
+module.exports = preventDefault;
+
+},{}],40:[function(require,module,exports){
+'use strict';
+
+/*
+ * Module dependencies.
+ */
+
+var JSON = require('json3');
+var base64encode = require('@segment/base64-encode');
+var cors = require('has-cors');
+var jsonp = require('jsonp');
+
+/*
+ * Exports.
+ */
+
+exports = module.exports = cors ? json : base64;
+
+/**
+ * Expose `callback`
+ */
+
+exports.callback = 'callback';
+
+/**
+ * Expose `prefix`
+ */
+
+exports.prefix = 'data';
+
+/**
+ * Expose `json`.
+ */
+
+exports.json = json;
+
+/**
+ * Expose `base64`.
+ */
+
+exports.base64 = base64;
+
+/**
+ * Expose `type`
+ */
+
+exports.type = cors ? 'xhr' : 'jsonp';
+
+/**
+ * Send the given `obj` to `url` with `fn(err, req)`.
+ *
+ * @param {String} url
+ * @param {Object} obj
+ * @param {Object} headers
+ * @param {Function} fn
+ * @api private
+ */
+
+function json(url, obj, headers, fn) {
+ if (arguments.length === 3) fn = headers, headers = {};
+
+ var req = new XMLHttpRequest;
+ req.onerror = fn;
+ req.onreadystatechange = done;
+ req.open('POST', url, true);
+
+ // TODO: Remove this eslint disable
+ // eslint-disable-next-line guard-for-in
+ for (var k in headers) {
+ req.setRequestHeader(k, headers[k]);
+ }
+ req.send(JSON.stringify(obj));
+
+ function done() {
+ if (req.readyState === 4) {
+ return fn(null, req);
+ }
+ }
+}
+
+/**
+ * Send the given `obj` to `url` with `fn(err, req)`.
+ *
+ * @param {String} url
+ * @param {Object} obj
+ * @param {Function} fn
+ * @api private
+ */
+
+function base64(url, obj, _, fn) {
+ if (arguments.length === 3) fn = _;
+
+ var prefix = exports.prefix;
+ var data = encode(obj);
+ url += '?' + prefix + '=' + data;
+ jsonp(url, { param: exports.callback }, function(err, obj) {
+ if (err) return fn(err);
+ fn(null, {
+ url: url,
+ body: obj
+ });
+ });
+}
+
+/**
+ * Encodes `obj`.
+ *
+ * @param {Object} obj
+ */
+
+function encode(obj) {
+ var str = '';
+ str = JSON.stringify(obj);
+ str = base64encode(str);
+ str = str.replace(/\+/g, '-').replace(/\//g, '_');
+ return encodeURIComponent(str);
+}
+
+},{"@segment/base64-encode":32,"has-cors":63,"json3":67,"jsonp":68}],41:[function(require,module,exports){
+(function (global){(function (){
+"use strict"
+
+var JSON = require('json3');
+
+module.exports = (function() {
+ // Store.js
+ var store = {},
+ win = (typeof window != 'undefined' ? window : global),
+ doc = win.document,
+ localStorageName = 'localStorage',
+ scriptTag = 'script',
+ storage
+
+ store.disabled = false
+ store.version = '1.3.20'
+ store.set = function(key, value) {}
+ store.get = function(key, defaultVal) {}
+ store.has = function(key) { return store.get(key) !== undefined }
+ store.remove = function(key) {}
+ store.clear = function() {}
+ store.transact = function(key, defaultVal, transactionFn) {
+ if (transactionFn == null) {
+ transactionFn = defaultVal
+ defaultVal = null
+ }
+ if (defaultVal == null) {
+ defaultVal = {}
+ }
+ var val = store.get(key, defaultVal)
+ transactionFn(val)
+ store.set(key, val)
+ }
+ store.getAll = function() {
+ var ret = {}
+ store.forEach(function(key, val) {
+ ret[key] = val
+ })
+ return ret
+ }
+ store.forEach = function() {}
+ store.serialize = function(value) {
+ return JSON.stringify(value)
+ }
+ store.deserialize = function(value) {
+ if (typeof value != 'string') { return undefined }
+ try { return JSON.parse(value) }
+ catch(e) { return value || undefined }
+ }
+
+ // Functions to encapsulate questionable FireFox 3.6.13 behavior
+ // when about.config::dom.storage.enabled === false
+ // See https://github.com/marcuswestin/store.js/issues#issue/13
+ function isLocalStorageNameSupported() {
+ try { return (localStorageName in win && win[localStorageName]) }
+ catch(err) { return false }
+ }
+
+ if (isLocalStorageNameSupported()) {
+ storage = win[localStorageName]
+ store.set = function(key, val) {
+ if (val === undefined) { return store.remove(key) }
+ storage.setItem(key, store.serialize(val))
+ return val
+ }
+ store.get = function(key, defaultVal) {
+ var val = store.deserialize(storage.getItem(key))
+ return (val === undefined ? defaultVal : val)
+ }
+ store.remove = function(key) { storage.removeItem(key) }
+ store.clear = function() { storage.clear() }
+ store.forEach = function(callback) {
+ for (var i=0; i<storage.length; i++) {
+ var key = storage.key(i)
+ callback(key, store.get(key))
+ }
+ }
+ } else if (doc && doc.documentElement.addBehavior) {
+ var storageOwner,
+ storageContainer
+ // Since #userData storage applies only to specific paths, we need to
+ // somehow link our data to a specific path. We choose /favicon.ico
+ // as a pretty safe option, since all browsers already make a request to
+ // this URL anyway and being a 404 will not hurt us here. We wrap an
+ // iframe pointing to the favicon in an ActiveXObject(htmlfile) object
+ // (see: http://msdn.microsoft.com/en-us/library/aa752574(v=VS.85).aspx)
+ // since the iframe access rules appear to allow direct access and
+ // manipulation of the document element, even for a 404 page. This
+ // document can be used instead of the current document (which would
+ // have been limited to the current path) to perform #userData storage.
+ try {
+ storageContainer = new ActiveXObject('htmlfile')
+ storageContainer.open()
+ storageContainer.write('<'+scriptTag+'>document.w=window</'+scriptTag+'><iframe src="/favicon.ico"></iframe>')
+ storageContainer.close()
+ storageOwner = storageContainer.w.frames[0].document
+ storage = storageOwner.createElement('div')
+ } catch(e) {
+ // somehow ActiveXObject instantiation failed (perhaps some special
+ // security settings or otherwse), fall back to per-path storage
+ storage = doc.createElement('div')
+ storageOwner = doc.body
+ }
+ var withIEStorage = function(storeFunction) {
+ return function() {
+ var args = Array.prototype.slice.call(arguments, 0)
+ args.unshift(storage)
+ // See http://msdn.microsoft.com/en-us/library/ms531081(v=VS.85).aspx
+ // and http://msdn.microsoft.com/en-us/library/ms531424(v=VS.85).aspx
+ storageOwner.appendChild(storage)
+ storage.addBehavior('#default#userData')
+ storage.load(localStorageName)
+ var result = storeFunction.apply(store, args)
+ storageOwner.removeChild(storage)
+ return result
+ }
+ }
+
+ // In IE7, keys cannot start with a digit or contain certain chars.
+ // See https://github.com/marcuswestin/store.js/issues/40
+ // See https://github.com/marcuswestin/store.js/issues/83
+ var forbiddenCharsRegex = new RegExp("[!\"#$%&'()*+,/\\\\:;<=>?@[\\]^`{|}~]", "g")
+ var ieKeyFix = function(key) {
+ return key.replace(/^d/, '___$&').replace(forbiddenCharsRegex, '___')
+ }
+ store.set = withIEStorage(function(storage, key, val) {
+ key = ieKeyFix(key)
+ if (val === undefined) { return store.remove(key) }
+ storage.setAttribute(key, store.serialize(val))
+ storage.save(localStorageName)
+ return val
+ })
+ store.get = withIEStorage(function(storage, key, defaultVal) {
+ key = ieKeyFix(key)
+ var val = store.deserialize(storage.getAttribute(key))
+ return (val === undefined ? defaultVal : val)
+ })
+ store.remove = withIEStorage(function(storage, key) {
+ key = ieKeyFix(key)
+ storage.removeAttribute(key)
+ storage.save(localStorageName)
+ })
+ store.clear = withIEStorage(function(storage) {
+ var attributes = storage.XMLDocument.documentElement.attributes
+ storage.load(localStorageName)
+ for (var i=attributes.length-1; i>=0; i--) {
+ storage.removeAttribute(attributes[i].name)
+ }
+ storage.save(localStorageName)
+ })
+ store.forEach = withIEStorage(function(storage, callback) {
+ var attributes = storage.XMLDocument.documentElement.attributes
+ for (var i=0, attr; attr=attributes[i]; ++i) {
+ callback(attr.name, store.deserialize(storage.getAttribute(attr.name)))
+ }
+ })
+ }
+
+ try {
+ var testKey = '__storejs__'
+ store.set(testKey, testKey)
+ if (store.get(testKey) != testKey) { store.disabled = true }
+ store.remove(testKey)
+ } catch(e) {
+ store.disabled = true
+ }
+ store.enabled = !store.disabled
+
+ return store
+}())
+
+}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"json3":67}],42:[function(require,module,exports){
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+var parse = require('component-url').parse;
+var cookie = require('component-cookie');
+
+/**
+ * Get the top domain.
+ *
+ * The function constructs the levels of domain and attempts to set a global
+ * cookie on each one when it succeeds it returns the top level domain.
+ *
+ * The method returns an empty string when the hostname is an ip or `localhost`.
+ *
+ * Example levels:
+ *
+ * domain.levels('http://www.google.co.uk');
+ * // => ["co.uk", "google.co.uk", "www.google.co.uk"]
+ *
+ * Example:
+ *
+ * domain('http://localhost:3000/baz');
+ * // => ''
+ * domain('http://dev:3000/baz');
+ * // => ''
+ * domain('http://127.0.0.1:3000/baz');
+ * // => ''
+ * domain('http://segment.io/baz');
+ * // => 'segment.io'
+ *
+ * @param {string} url
+ * @return {string}
+ * @api public
+ */
+function domain(url) {
+ var cookie = exports.cookie;
+ var levels = exports.levels(url);
+
+ // Lookup the real top level one.
+ for (var i = 0; i < levels.length; ++i) {
+ var cname = '__tld__';
+ var domain = levels[i];
+ var opts = { domain: '.' + domain };
+
+ cookie(cname, 1, opts);
+ if (cookie(cname)) {
+ cookie(cname, null, opts);
+ return domain;
+ }
+ }
+
+ return '';
+}
+
+/**
+ * Levels returns all levels of the given url.
+ *
+ * @param {string} url
+ * @return {Array}
+ * @api public
+ */
+domain.levels = function(url) {
+ var host = parse(url).hostname;
+ var parts = host.split('.');
+ var last = parts[parts.length - 1];
+ var levels = [];
+
+ // Ip address.
+ if (parts.length === 4 && last === parseInt(last, 10)) {
+ return levels;
+ }
+
+ // Localhost.
+ if (parts.length <= 1) {
+ return levels;
+ }
+
+ // Create levels.
+ for (var i = parts.length - 2; i >= 0; --i) {
+ levels.push(parts.slice(i).join('.'));
+ }
+
+ return levels;
+};
+
+/**
+ * Expose cookie on domain.
+ */
+domain.cookie = cookie;
+
+/*
+ * Exports.
+ */
+
+exports = module.exports = domain;
+
+},{"component-cookie":46,"component-url":58}],43:[function(require,module,exports){
+'use strict';
+
+/**
+ * Module Dependencies
+ */
+
+var map = require('@ndhoule/map');
+var foldl = require('@ndhoule/foldl');
+
+var eventMap = {
+ // Videos
+ videoPlaybackStarted: [{
+ object: 'video playback',
+ action: 'started'
+ }],
+ videoPlaybackPaused: [{
+ object: 'video playback',
+ action: 'paused'
+ }],
+ videoPlaybackInterrupted: [{
+ object: 'video playback',
+ action: 'interrupted'
+ }],
+ videoPlaybackResumed: [{
+ object: 'video playback',
+ action: 'resumed'
+ }],
+ videoPlaybackCompleted: [{
+ object: 'video playback',
+ action: 'completed'
+ }],
+ videoPlaybackBufferStarted: [{
+ object: 'video playback buffer',
+ action: 'started'
+ }],
+ videoPlaybackBufferCompleted: [{
+ object: 'video playback buffer',
+ action: 'completed'
+ }],
+ videoPlaybackSeekStarted: [{
+ object: 'video playback seek',
+ action: 'started'
+ }],
+ videoPlaybackSeekCompleted: [{
+ object: 'video playback seek',
+ action: 'completed'
+ }],
+ videoContentStarted: [{
+ object: 'video content',
+ action: 'started'
+ }],
+ videoContentPlaying: [{
+ object: 'video content',
+ action: 'playing'
+ }],
+ videoContentCompleted: [{
+ object: 'video content',
+ action: 'completed'
+ }],
+ videoAdStarted: [{
+ object: 'video ad',
+ action: 'started'
+ }],
+ videoAdPlaying: [{
+ object: 'video ad',
+ action: 'playing'
+ }],
+ videoAdCompleted: [{
+ object: 'video ad',
+ action: 'completed'
+ }],
+
+ // Promotions
+ promotionViewed: [{
+ object: 'promotion',
+ action: 'viewed'
+ }],
+ promotionClicked: [{
+ object: 'promotion',
+ action: 'clicked'
+ }],
+
+ // Browsing
+ productsSearched: [{
+ object: 'products',
+ action: 'searched'
+ }],
+ productListViewed: [{
+ object: 'product list',
+ action: 'viewed'
+ }, {
+ object: 'product category',
+ action: 'viewed'
+ }],
+ productListFiltered: [{
+ object: 'product list',
+ action: 'filtered'
+ }],
+
+ // Core Ordering
+ productClicked: [{
+ object: 'product',
+ action: 'clicked'
+ }],
+ productViewed: [{
+ object: 'product',
+ action: 'viewed'
+ }],
+ productAdded: [{
+ object: 'product',
+ action: 'added'
+ }],
+ productRemoved: [{
+ object: 'product',
+ action: 'removed'
+ }],
+ cartViewed: [{
+ object: 'cart',
+ action: 'viewed'
+ }],
+ orderUpdated: [{
+ object: 'order',
+ action: 'updated'
+ }],
+ orderCompleted: [{
+ object: 'order',
+ action: 'completed'
+ }],
+ orderRefunded: [{
+ object: 'order',
+ action: 'refunded'
+ }],
+ orderCancelled: [{
+ object: 'order',
+ action: 'cancelled'
+ }],
+ paymentInfoEntered: [{
+ object: 'payment info',
+ action: 'entered'
+ }],
+ checkoutStarted: [{
+ object: 'checkout',
+ action: 'started'
+ }],
+ checkoutStepViewed: [{
+ object: 'checkout step',
+ action: 'viewed'
+ }],
+ checkoutStepCompleted: [{
+ object: 'checkout step',
+ action: 'completed'
+ }],
+
+ // Coupons
+ couponEntered: [{
+ object: 'coupon',
+ action: 'entered'
+ }],
+ couponApplied: [{
+ object: 'coupon',
+ action: 'applied'
+ }],
+ couponDenied: [{
+ object: 'coupon',
+ action: 'denied'
+ }],
+ couponRemoved: [{
+ object: 'coupon',
+ action: 'removed'
+ }],
+
+ // Wishlisting
+ productAddedToWishlist: [{
+ object: 'product',
+ action: 'added to wishlist'
+ }],
+ productRemovedFromWishlist: [{
+ object: 'product',
+ action: 'removed from wishlist'
+ }],
+ productAddedFromWishlistToCart: [{
+ object: 'product',
+ action: 'added to cart from wishlist'
+ }, {
+ object: 'product',
+ action: 'added from wishlist to cart'
+ }],
+
+ // Sharing
+ productShared: [{
+ object: 'product',
+ action: 'shared'
+ }],
+ cartShared: [{
+ object: 'cart',
+ action: 'shared'
+ }],
+
+ // Reviewing
+ productReviewed: [{
+ object: 'product',
+ action: 'reviewed'
+ }],
+
+ // App Lifecycle
+ applicationInstalled: [{
+ object: 'application',
+ action: 'installed'
+ }],
+ applicationUpdated: [{
+ object: 'application',
+ action: 'updated'
+ }],
+ applicationOpened: [{
+ object: 'application',
+ action: 'opened'
+ }],
+ applicationBackgrounded: [{
+ object: 'application',
+ action: 'backgrounded'
+ }],
+ applicationUninstalled: [{
+ object: 'application',
+ action: 'uninstalled'
+ }],
+ applicationCrashed: [{
+ object: 'application',
+ action: 'crashed'
+ }],
+
+ // App Campaign and Referral Events
+ installAttributed: [{
+ object: 'install',
+ action: 'attributed'
+ }],
+ deepLinkOpened: [{
+ object: 'deep link',
+ action: 'opened'
+ }],
+ pushNotificationReceived: [{
+ object: 'push notification',
+ action: 'received'
+ }],
+ pushNotificationTapped: [{
+ object: 'push notification',
+ action: 'tapped'
+ }],
+ pushNotificationBounced: [{
+ object: 'push notification',
+ action: 'bounced'
+ }],
+
+ // Email
+ emailBounced: [{
+ object: 'email',
+ action: 'bounced'
+ }],
+ emailDelivered: [{
+ object: 'email',
+ action: 'delivered'
+ }],
+ emailLinkClicked: [{
+ object: 'email link',
+ action: 'clicked'
+ }],
+ emailMarkedAsSpam: [{
+ object: 'email',
+ action: 'marked as spam'
+ }],
+ emailOpened: [{
+ object: 'email',
+ action: 'opened'
+ }],
+ unsubscribed: [{
+ object: '',
+ action: 'unsubscribed'
+ }]
+};
+
+/**
+ * Export the event map
+ *
+ * For each method
+ * - For each of its object:action alias pairs
+ * - For each permutation of that pair
+ * - Create a regex string
+ * - Join them and assign it to its respective method value
+ *
+ * [{
+ * object: 'product list',
+ * action: 'viewed'
+ * },{
+ * object: 'product category',
+ * action: 'viewed'
+ * }] => /
+ * ^[ _]?product[ _]?list[ _]?viewed[ _]?
+ * |^[ _]?viewed[ _]?product[ _]?list[ _]?
+ * |^[ _]?product[ _]?category[ _]?viewed[ _]?
+ * |^[ _]?viewed[ _]?product[ _]?category[ _]?
+ * $/i
+ *
+ * todo(cs/wj/nh): memoization strategy / build step?
+ */
+
+module.exports = foldl(function transform(ret, pairs, method) {
+ var values = map(function(pair) {
+ return map(function(permutation) {
+ var flattened = [].concat.apply([], map(function(words) {
+ return words.split(' ');
+ }, permutation));
+ return '^[ _]?' + flattened.join('[ _]?') + '[ _]?';
+ }, [
+ [pair.action, pair.object],
+ [pair.object, pair.action]
+ ]).join('|');
+ }, pairs);
+ var conjoined = values.join('|') + '$';
+ ret[method] = new RegExp(conjoined, 'i');
+ return ret;
+}, {}, eventMap);
+
+},{"@ndhoule/foldl":9,"@ndhoule/map":12}],44:[function(require,module,exports){
+'use strict';
+
+var bind = require('component-bind');
+
+function bindAll(obj) {
+ // eslint-disable-next-line guard-for-in
+ for (var key in obj) {
+ var val = obj[key];
+ if (typeof val === 'function') {
+ obj[key] = bind(obj, obj[key]);
+ }
+ }
+ return obj;
+}
+
+module.exports = bindAll;
+
+},{"component-bind":45}],45:[function(require,module,exports){
+/**
+ * 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)));
+ }
+};
+
+},{}],46:[function(require,module,exports){
+
+/**
+ * Module dependencies.
+ */
+
+var debug = require('debug')('cookie');
+
+/**
+ * Set or get cookie `name` with `value` and `options` object.
+ *
+ * @param {String} name
+ * @param {String} value
+ * @param {Object} options
+ * @return {Mixed}
+ * @api public
+ */
+
+module.exports = function(name, value, options){
+ switch (arguments.length) {
+ case 3:
+ case 2:
+ return set(name, value, options);
+ case 1:
+ return get(name);
+ default:
+ return all();
+ }
+};
+
+/**
+ * Set cookie `name` to `value`.
+ *
+ * @param {String} name
+ * @param {String} value
+ * @param {Object} options
+ * @api private
+ */
+
+function set(name, value, options) {
+ options = options || {};
+ var str = encode(name) + '=' + encode(value);
+
+ if (null == value) options.maxage = -1;
+
+ if (options.maxage) {
+ options.expires = new Date(+new Date + options.maxage);
+ }
+
+ if (options.path) str += '; path=' + options.path;
+ if (options.domain) str += '; domain=' + options.domain;
+ if (options.expires) str += '; expires=' + options.expires.toUTCString();
+ if (options.secure) str += '; secure';
+
+ document.cookie = str;
+}
+
+/**
+ * Return all cookies.
+ *
+ * @return {Object}
+ * @api private
+ */
+
+function all() {
+ var str;
+ try {
+ str = document.cookie;
+ } catch (err) {
+ if (typeof console !== 'undefined' && typeof console.error === 'function') {
+ console.error(err.stack || err);
+ }
+ return {};
+ }
+ return parse(str);
+}
+
+/**
+ * Get cookie `name`.
+ *
+ * @param {String} name
+ * @return {String}
+ * @api private
+ */
+
+function get(name) {
+ return all()[name];
+}
+
+/**
+ * Parse cookie `str`.
+ *
+ * @param {String} str
+ * @return {Object}
+ * @api private
+ */
+
+function parse(str) {
+ var obj = {};
+ var pairs = str.split(/ *; */);
+ var pair;
+ if ('' == pairs[0]) return obj;
+ for (var i = 0; i < pairs.length; ++i) {
+ pair = pairs[i].split('=');
+ obj[decode(pair[0])] = decode(pair[1]);
+ }
+ return obj;
+}
+
+/**
+ * Encode.
+ */
+
+function encode(value){
+ try {
+ return encodeURIComponent(value);
+ } catch (e) {
+ debug('error `encode(%o)` - %o', value, e)
+ }
+}
+
+/**
+ * Decode.
+ */
+
+function decode(value) {
+ try {
+ return decodeURIComponent(value);
+ } catch (e) {
+ debug('error `decode(%o)` - %o', value, e)
+ }
+}
+
+},{"debug":47}],47:[function(require,module,exports){
+
+/**
+ * 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) {}
+}
+
+},{"./debug":48}],48:[function(require,module,exports){
+
+/**
+ * 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;
+}
+
+},{"ms":49}],49:[function(require,module,exports){
+/**
+ * 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';
+}
+
+},{}],50:[function(require,module,exports){
+
+/**
+ * Module dependencies.
+ */
+
+try {
+ var type = require('type');
+} catch (err) {
+ var type = require('component-type');
+}
+
+var toFunction = require('to-function');
+
+/**
+ * HOP reference.
+ */
+
+var has = Object.prototype.hasOwnProperty;
+
+/**
+ * Iterate the given `obj` and invoke `fn(val, i)`
+ * in optional context `ctx`.
+ *
+ * @param {String|Array|Object} obj
+ * @param {Function} fn
+ * @param {Object} [ctx]
+ * @api public
+ */
+
+module.exports = function(obj, fn, ctx){
+ fn = toFunction(fn);
+ ctx = ctx || this;
+ switch (type(obj)) {
+ case 'array':
+ return array(obj, fn, ctx);
+ case 'object':
+ if ('number' == typeof obj.length) return array(obj, fn, ctx);
+ return object(obj, fn, ctx);
+ case 'string':
+ return string(obj, fn, ctx);
+ }
+};
+
+/**
+ * Iterate string chars.
+ *
+ * @param {String} obj
+ * @param {Function} fn
+ * @param {Object} ctx
+ * @api private
+ */
+
+function string(obj, fn, ctx) {
+ for (var i = 0; i < obj.length; ++i) {
+ fn.call(ctx, obj.charAt(i), i);
+ }
+}
+
+/**
+ * Iterate object keys.
+ *
+ * @param {Object} obj
+ * @param {Function} fn
+ * @param {Object} ctx
+ * @api private
+ */
+
+function object(obj, fn, ctx) {
+ for (var key in obj) {
+ if (has.call(obj, key)) {
+ fn.call(ctx, key, obj[key]);
+ }
+ }
+}
+
+/**
+ * Iterate array-ish.
+ *
+ * @param {Array|Object} obj
+ * @param {Function} fn
+ * @param {Object} ctx
+ * @api private
+ */
+
+function array(obj, fn, ctx) {
+ for (var i = 0; i < obj.length; ++i) {
+ fn.call(ctx, obj[i], i);
+ }
+}
+
+},{"component-type":51,"to-function":95,"type":51}],51:[function(require,module,exports){
+
+/**
+ * toString ref.
+ */
+
+var toString = Object.prototype.toString;
+
+/**
+ * Return the type of `val`.
+ *
+ * @param {Mixed} val
+ * @return {String}
+ * @api public
+ */
+
+module.exports = function(val){
+ switch (toString.call(val)) {
+ case '[object Function]': return 'function';
+ case '[object Date]': return 'date';
+ case '[object RegExp]': return 'regexp';
+ case '[object Arguments]': return 'arguments';
+ case '[object Array]': return 'array';
+ case '[object String]': return 'string';
+ }
+
+ if (val === null) return 'null';
+ if (val === undefined) return 'undefined';
+ if (val && val.nodeType === 1) return 'element';
+ if (val === Object(val)) return 'object';
+
+ return typeof val;
+};
+
+},{}],52:[function(require,module,exports){
+
+/**
+ * Expose `Emitter`.
+ */
+
+if (typeof module !== 'undefined') {
+ 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;
+ }
+ }
+
+ // Remove event specific arrays for event types that no
+ // one is subscribed for to avoid memory leak.
+ if (callbacks.length === 0) {
+ delete this._callbacks['$' + event];
+ }
+
+ 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 = new Array(arguments.length - 1)
+ , callbacks = this._callbacks['$' + event];
+
+ for (var i = 1; i < arguments.length; i++) {
+ args[i - 1] = arguments[i];
+ }
+
+ 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;
+};
+
+},{}],53:[function(require,module,exports){
+var bind = window.addEventListener ? 'addEventListener' : 'attachEvent',
+ unbind = window.removeEventListener ? 'removeEventListener' : 'detachEvent',
+ prefix = bind !== 'addEventListener' ? 'on' : '';
+
+/**
+ * Bind `el` event `type` to `fn`.
+ *
+ * @param {Element} el
+ * @param {String} type
+ * @param {Function} fn
+ * @param {Boolean} capture
+ * @return {Function}
+ * @api public
+ */
+
+exports.bind = function(el, type, fn, capture){
+ el[bind](prefix + type, fn, capture || false);
+ return fn;
+};
+
+/**
+ * Unbind `el` event `type`'s callback `fn`.
+ *
+ * @param {Element} el
+ * @param {String} type
+ * @param {Function} fn
+ * @param {Boolean} capture
+ * @return {Function}
+ * @api public
+ */
+
+exports.unbind = function(el, type, fn, capture){
+ el[unbind](prefix + type, fn, capture || false);
+ return fn;
+};
+},{}],54:[function(require,module,exports){
+/**
+ * Global Names
+ */
+
+var globals = /\b(Array|Date|Object|Math|JSON)\b/g;
+
+/**
+ * Return immediate identifiers parsed from `str`.
+ *
+ * @param {String} str
+ * @param {String|Function} map function or prefix
+ * @return {Array}
+ * @api public
+ */
+
+module.exports = function(str, fn){
+ var p = unique(props(str));
+ if (fn && 'string' == typeof fn) fn = prefixed(fn);
+ if (fn) return map(str, p, fn);
+ return p;
+};
+
+/**
+ * Return immediate identifiers in `str`.
+ *
+ * @param {String} str
+ * @return {Array}
+ * @api private
+ */
+
+function props(str) {
+ return str
+ .replace(/\.\w+|\w+ *\(|"[^"]*"|'[^']*'|\/([^/]+)\//g, '')
+ .replace(globals, '')
+ .match(/[a-zA-Z_]\w*/g)
+ || [];
+}
+
+/**
+ * Return `str` with `props` mapped with `fn`.
+ *
+ * @param {String} str
+ * @param {Array} props
+ * @param {Function} fn
+ * @return {String}
+ * @api private
+ */
+
+function map(str, props, fn) {
+ var re = /\.\w+|\w+ *\(|"[^"]*"|'[^']*'|\/([^/]+)\/|[a-zA-Z_]\w*/g;
+ return str.replace(re, function(_){
+ if ('(' == _[_.length - 1]) return fn(_);
+ if (!~props.indexOf(_)) return _;
+ return fn(_);
+ });
+}
+
+/**
+ * Return unique array.
+ *
+ * @param {Array} arr
+ * @return {Array}
+ * @api private
+ */
+
+function unique(arr) {
+ var ret = [];
+
+ for (var i = 0; i < arr.length; i++) {
+ if (~ret.indexOf(arr[i])) continue;
+ ret.push(arr[i]);
+ }
+
+ return ret;
+}
+
+/**
+ * Map with prefix `str`.
+ */
+
+function prefixed(str) {
+ return function(_){
+ return str + _;
+ };
+}
+
+},{}],55:[function(require,module,exports){
+
+/**
+ * Module dependencies.
+ */
+
+var trim = require('trim');
+var type = require('type');
+
+var pattern = /(\w+)\[(\d+)\]/
+
+/**
+ * Safely encode the given string
+ *
+ * @param {String} str
+ * @return {String}
+ * @api private
+ */
+
+var encode = function(str) {
+ try {
+ return encodeURIComponent(str);
+ } catch (e) {
+ return str;
+ }
+};
+
+/**
+ * Safely decode the string
+ *
+ * @param {String} str
+ * @return {String}
+ * @api private
+ */
+
+var decode = function(str) {
+ try {
+ return decodeURIComponent(str.replace(/\+/g, ' '));
+ } catch (e) {
+ return str;
+ }
+}
+
+/**
+ * Parse the given query `str`.
+ *
+ * @param {String} str
+ * @return {Object}
+ * @api public
+ */
+
+exports.parse = function(str){
+ if ('string' != typeof str) return {};
+
+ str = trim(str);
+ if ('' == str) return {};
+ if ('?' == str.charAt(0)) str = str.slice(1);
+
+ var obj = {};
+ var pairs = str.split('&');
+ for (var i = 0; i < pairs.length; i++) {
+ var parts = pairs[i].split('=');
+ var key = decode(parts[0]);
+ var m;
+
+ if (m = pattern.exec(key)) {
+ obj[m[1]] = obj[m[1]] || [];
+ obj[m[1]][m[2]] = decode(parts[1]);
+ continue;
+ }
+
+ obj[parts[0]] = null == parts[1]
+ ? ''
+ : decode(parts[1]);
+ }
+
+ return obj;
+};
+
+/**
+ * Stringify the given `obj`.
+ *
+ * @param {Object} obj
+ * @return {String}
+ * @api public
+ */
+
+exports.stringify = function(obj){
+ if (!obj) return '';
+ var pairs = [];
+
+ for (var key in obj) {
+ var value = obj[key];
+
+ if ('array' == type(value)) {
+ for (var i = 0; i < value.length; ++i) {
+ pairs.push(encode(key + '[' + i + ']') + '=' + encode(value[i]));
+ }
+ continue;
+ }
+
+ pairs.push(encode(key) + '=' + encode(obj[key]));
+ }
+
+ return pairs.join('&');
+};
+
+},{"trim":97,"type":56}],56:[function(require,module,exports){
+/**
+ * toString ref.
+ */
+
+var toString = Object.prototype.toString;
+
+/**
+ * Return the type of `val`.
+ *
+ * @param {Mixed} val
+ * @return {String}
+ * @api public
+ */
+
+module.exports = function(val){
+ switch (toString.call(val)) {
+ case '[object Date]': return 'date';
+ case '[object RegExp]': return 'regexp';
+ case '[object Arguments]': return 'arguments';
+ case '[object Array]': return 'array';
+ case '[object Error]': return 'error';
+ }
+
+ if (val === null) return 'null';
+ if (val === undefined) return 'undefined';
+ if (val !== val) return 'nan';
+ if (val && val.nodeType === 1) return 'element';
+
+ val = val.valueOf
+ ? val.valueOf()
+ : Object.prototype.valueOf.apply(val)
+
+ return typeof val;
+};
+
+},{}],57:[function(require,module,exports){
+/**
+ * toString ref.
+ */
+
+var toString = Object.prototype.toString;
+
+/**
+ * Return the type of `val`.
+ *
+ * @param {Mixed} val
+ * @return {String}
+ * @api public
+ */
+
+module.exports = function(val){
+ switch (toString.call(val)) {
+ case '[object Date]': return 'date';
+ case '[object RegExp]': return 'regexp';
+ case '[object Arguments]': return 'arguments';
+ case '[object Array]': return 'array';
+ case '[object Error]': return 'error';
+ }
+
+ if (val === null) return 'null';
+ if (val === undefined) return 'undefined';
+ if (val !== val) return 'nan';
+ if (val && val.nodeType === 1) return 'element';
+
+ if (isBuffer(val)) return 'buffer';
+
+ val = val.valueOf
+ ? val.valueOf()
+ : Object.prototype.valueOf.apply(val);
+
+ return typeof val;
+};
+
+// code borrowed from https://github.com/feross/is-buffer/blob/master/index.js
+function isBuffer(obj) {
+ return !!(obj != null &&
+ (obj._isBuffer || // For Safari 5-7 (missing Object.prototype.constructor)
+ (obj.constructor &&
+ typeof obj.constructor.isBuffer === 'function' &&
+ obj.constructor.isBuffer(obj))
+ ))
+}
+
+},{}],58:[function(require,module,exports){
+
+/**
+ * Parse the given `url`.
+ *
+ * @param {String} str
+ * @return {Object}
+ * @api public
+ */
+
+exports.parse = function(url){
+ var a = document.createElement('a');
+ a.href = url;
+ return {
+ href: a.href,
+ host: a.host || location.host,
+ port: ('0' === a.port || '' === a.port) ? port(a.protocol) : a.port,
+ hash: a.hash,
+ hostname: a.hostname || location.hostname,
+ pathname: a.pathname.charAt(0) != '/' ? '/' + a.pathname : a.pathname,
+ protocol: !a.protocol || ':' == a.protocol ? location.protocol : a.protocol,
+ search: a.search,
+ query: a.search.slice(1)
+ };
+};
+
+/**
+ * Check if `url` is absolute.
+ *
+ * @param {String} url
+ * @return {Boolean}
+ * @api public
+ */
+
+exports.isAbsolute = function(url){
+ return 0 == url.indexOf('//') || !!~url.indexOf('://');
+};
+
+/**
+ * Check if `url` is relative.
+ *
+ * @param {String} url
+ * @return {Boolean}
+ * @api public
+ */
+
+exports.isRelative = function(url){
+ return !exports.isAbsolute(url);
+};
+
+/**
+ * Check if `url` is cross domain.
+ *
+ * @param {String} url
+ * @return {Boolean}
+ * @api public
+ */
+
+exports.isCrossDomain = function(url){
+ url = exports.parse(url);
+ var location = exports.parse(window.location.href);
+ return url.hostname !== location.hostname
+ || url.port !== location.port
+ || url.protocol !== location.protocol;
+};
+
+/**
+ * Return default port for `protocol`.
+ *
+ * @param {String} protocol
+ * @return {String}
+ * @api private
+ */
+function port (protocol){
+ switch (protocol) {
+ case 'http:':
+ return 80;
+ case 'https:':
+ return 443;
+ default:
+ return location.port;
+ }
+}
+
+},{}],59:[function(require,module,exports){
+(function (process){(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() {
+ // NB: In an Electron preload script, document will be defined but not fully
+ // initialized. Since we know we're in Chrome, we'll just detect this case
+ // explicitly
+ if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {
+ return true;
+ }
+
+ // is webkit? http://stackoverflow.com/a/16459606/376773
+ // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+ return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+ // is firebug? http://stackoverflow.com/a/398120/376773
+ (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+ // is firefox >= v31?
+ // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+ (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+ // double check webkit in userAgent just in case we are in a worker
+ (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+}
+
+/**
+ * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+ */
+
+exports.formatters.j = function(v) {
+ try {
+ return JSON.stringify(v);
+ } catch (err) {
+ return '[UnexpectedJSONParseError]: ' + err.message;
+ }
+};
+
+
+/**
+ * Colorize log arguments if enabled.
+ *
+ * @api public
+ */
+
+function formatArgs(args) {
+ var useColors = this.useColors;
+
+ args[0] = (useColors ? '%c' : '')
+ + this.namespace
+ + (useColors ? ' %c' : ' ')
+ + args[0]
+ + (useColors ? '%c ' : ' ')
+ + '+' + exports.humanize(this.diff);
+
+ if (!useColors) return;
+
+ var c = 'color: ' + this.color;
+ args.splice(1, 0, c, 'color: inherit')
+
+ // 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-zA-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);
+}
+
+/**
+ * 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) {}
+
+ // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+ if (!r && typeof process !== 'undefined' && 'env' in process) {
+ r = process.env.DEBUG;
+ }
+
+ 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) {}
+}
+
+}).call(this)}).call(this,require('_process'))
+},{"./debug":60,"_process":78}],60:[function(require,module,exports){
+
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ *
+ * Expose `debug()` as the module.
+ */
+
+exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
+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, lower or upper-case letter, i.e. "n" and "N".
+ */
+
+exports.formatters = {};
+
+/**
+ * Previous log timestamp.
+ */
+
+var prevTime;
+
+/**
+ * Select a color.
+ * @param {String} namespace
+ * @return {Number}
+ * @api private
+ */
+
+function selectColor(namespace) {
+ var hash = 0, i;
+
+ for (i in namespace) {
+ hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+ hash |= 0; // Convert to 32bit integer
+ }
+
+ return exports.colors[Math.abs(hash) % exports.colors.length];
+}
+
+/**
+ * Create a debugger with the given `namespace`.
+ *
+ * @param {String} namespace
+ * @return {Function}
+ * @api public
+ */
+
+function createDebug(namespace) {
+
+ function debug() {
+ // disabled?
+ if (!debug.enabled) return;
+
+ var self = debug;
+
+ // set `diff` timestamp
+ var curr = +new Date();
+ var ms = curr - (prevTime || curr);
+ self.diff = ms;
+ self.prev = prevTime;
+ self.curr = curr;
+ prevTime = curr;
+
+ // turn the `arguments` into a proper Array
+ var args = new Array(arguments.length);
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i];
+ }
+
+ args[0] = exports.coerce(args[0]);
+
+ if ('string' !== typeof args[0]) {
+ // anything else let's inspect with %O
+ args.unshift('%O');
+ }
+
+ // apply any `formatters` transformations
+ var index = 0;
+ args[0] = args[0].replace(/%([a-zA-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;
+ });
+
+ // apply env-specific formatting (colors, etc.)
+ exports.formatArgs.call(self, args);
+
+ var logFn = debug.log || exports.log || console.log.bind(console);
+ logFn.apply(self, args);
+ }
+
+ debug.namespace = namespace;
+ debug.enabled = exports.enabled(namespace);
+ debug.useColors = exports.useColors();
+ debug.color = selectColor(namespace);
+
+ // env-specific initialization logic for debug instances
+ if ('function' === typeof exports.init) {
+ exports.init(debug);
+ }
+
+ return debug;
+}
+
+/**
+ * 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);
+
+ exports.names = [];
+ exports.skips = [];
+
+ var split = (typeof namespaces === 'string' ? 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;
+}
+
+},{"ms":71}],61:[function(require,module,exports){
+
+/**
+ * Expose `parse`.
+ */
+
+module.exports = parse;
+
+/**
+ * Tests for browser support.
+ */
+
+var innerHTMLBug = false;
+var bugTestDiv;
+if (typeof document !== 'undefined') {
+ bugTestDiv = document.createElement('div');
+ // Setup
+ bugTestDiv.innerHTML = ' <link/><table></table><a href="/a">a</a><input type="checkbox"/>';
+ // Make sure that link elements get serialized correctly by innerHTML
+ // This requires a wrapper element in IE
+ innerHTMLBug = !bugTestDiv.getElementsByTagName('link').length;
+ bugTestDiv = undefined;
+}
+
+/**
+ * Wrap map from jquery.
+ */
+
+var map = {
+ legend: [1, '<fieldset>', '</fieldset>'],
+ tr: [2, '<table><tbody>', '</tbody></table>'],
+ col: [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
+ // for script/link/style tags to work in IE6-8, you have to wrap
+ // in a div with a non-whitespace character in front, ha!
+ _default: innerHTMLBug ? [1, 'X<div>', '</div>'] : [0, '', '']
+};
+
+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.polyline =
+map.ellipse =
+map.polygon =
+map.circle =
+map.text =
+map.line =
+map.path =
+map.rect =
+map.g = [1, '<svg xmlns="http://www.w3.org/2000/svg" version="1.1">','</svg>'];
+
+/**
+ * Parse `html` and return a DOM Node instance, which could be a TextNode,
+ * HTML DOM Node of some kind (<div> for example), or a DocumentFragment
+ * instance, depending on the contents of the `html` string.
+ *
+ * @param {String} html - HTML string to "domify"
+ * @param {Document} doc - The `document` instance to create the Node for
+ * @return {DOMNode} the TextNode, DOM Node, or DocumentFragment instance
+ * @api private
+ */
+
+function parse(html, doc) {
+ if ('string' != typeof html) throw new TypeError('String expected');
+
+ // default to the global `document` object
+ if (!doc) doc = document;
+
+ // tag name
+ var m = /<([\w:]+)/.exec(html);
+ if (!m) return doc.createTextNode(html);
+
+ html = html.replace(/^\s+|\s+$/g, ''); // Remove leading/trailing whitespace
+
+ var tag = m[1];
+
+ // body support
+ if (tag == 'body') {
+ var el = doc.createElement('html');
+ el.innerHTML = html;
+ return el.removeChild(el.lastChild);
+ }
+
+ // wrap map
+ var wrap = map[tag] || map._default;
+ var depth = wrap[0];
+ var prefix = wrap[1];
+ var suffix = wrap[2];
+ var el = doc.createElement('div');
+ el.innerHTML = prefix + html + suffix;
+ while (depth--) el = el.lastChild;
+
+ // one element
+ if (el.firstChild == el.lastChild) {
+ return el.removeChild(el.firstChild);
+ }
+
+ // several elements
+ var fragment = doc.createDocumentFragment();
+ while (el.firstChild) {
+ fragment.appendChild(el.removeChild(el.firstChild));
+ }
+
+ return fragment;
+}
+
+},{}],62:[function(require,module,exports){
+'use strict';
+
+var hasOwn = Object.prototype.hasOwnProperty;
+var toStr = Object.prototype.toString;
+var defineProperty = Object.defineProperty;
+var gOPD = Object.getOwnPropertyDescriptor;
+
+var isArray = function isArray(arr) {
+ if (typeof Array.isArray === 'function') {
+ return Array.isArray(arr);
+ }
+
+ return toStr.call(arr) === '[object Array]';
+};
+
+var isPlainObject = function isPlainObject(obj) {
+ if (!obj || toStr.call(obj) !== '[object Object]') {
+ return false;
+ }
+
+ var hasOwnConstructor = hasOwn.call(obj, 'constructor');
+ var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
+ // Not own constructor property must be Object
+ if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
+ return false;
+ }
+
+ // Own properties are enumerated firstly, so to speed up,
+ // if last one is own, then all properties are own.
+ var key;
+ for (key in obj) { /**/ }
+
+ return typeof key === 'undefined' || hasOwn.call(obj, key);
+};
+
+// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target
+var setProperty = function setProperty(target, options) {
+ if (defineProperty && options.name === '__proto__') {
+ defineProperty(target, options.name, {
+ enumerable: true,
+ configurable: true,
+ value: options.newValue,
+ writable: true
+ });
+ } else {
+ target[options.name] = options.newValue;
+ }
+};
+
+// Return undefined instead of __proto__ if '__proto__' is not an own property
+var getProperty = function getProperty(obj, name) {
+ if (name === '__proto__') {
+ if (!hasOwn.call(obj, name)) {
+ return void 0;
+ } else if (gOPD) {
+ // In early versions of node, obj['__proto__'] is buggy when obj has
+ // __proto__ as an own property. Object.getOwnPropertyDescriptor() works.
+ return gOPD(obj, name).value;
+ }
+ }
+
+ return obj[name];
+};
+
+module.exports = function extend() {
+ var options, name, src, copy, copyIsArray, clone;
+ var target = arguments[0];
+ var i = 1;
+ var length = arguments.length;
+ var deep = false;
+
+ // Handle a deep copy situation
+ if (typeof target === 'boolean') {
+ deep = target;
+ target = arguments[1] || {};
+ // skip the boolean and the target
+ i = 2;
+ }
+ if (target == null || (typeof target !== 'object' && typeof target !== 'function')) {
+ target = {};
+ }
+
+ for (; i < length; ++i) {
+ options = arguments[i];
+ // Only deal with non-null/undefined values
+ if (options != null) {
+ // Extend the base object
+ for (name in options) {
+ src = getProperty(target, name);
+ copy = getProperty(options, name);
+
+ // Prevent never-ending loop
+ if (target !== copy) {
+ // Recurse if we're merging plain objects or arrays
+ if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
+ if (copyIsArray) {
+ copyIsArray = false;
+ clone = src && isArray(src) ? src : [];
+ } else {
+ clone = src && isPlainObject(src) ? src : {};
+ }
+
+ // Never move original objects, clone them
+ setProperty(target, { name: name, newValue: extend(deep, clone, copy) });
+
+ // Don't bring in undefined values
+ } else if (typeof copy !== 'undefined') {
+ setProperty(target, { name: name, newValue: copy });
+ }
+ }
+ }
+ }
+ }
+
+ // Return the modified object
+ return target;
+};
+
+},{}],63:[function(require,module,exports){
+
+/**
+ * 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;
+}
+
+},{}],64:[function(require,module,exports){
+if (typeof Object.create === 'function') {
+ // implementation from standard node.js 'util' module
+ module.exports = function inherits(ctor, superCtor) {
+ if (superCtor) {
+ ctor.super_ = superCtor
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ })
+ }
+ };
+} else {
+ // old school shim for old browsers
+ module.exports = function inherits(ctor, superCtor) {
+ if (superCtor) {
+ ctor.super_ = superCtor
+ var TempCtor = function () {}
+ TempCtor.prototype = superCtor.prototype
+ ctor.prototype = new TempCtor()
+ ctor.prototype.constructor = ctor
+ }
+ }
+}
+
+},{}],65:[function(require,module,exports){
+
+module.exports = function isEmail (string) {
+ return (/.+\@.+\..+/).test(string);
+};
+},{}],66:[function(require,module,exports){
+/* globals window, HTMLElement */
+
+'use strict';
+
+/**!
+ * is
+ * the definitive JavaScript type testing library
+ *
+ * @copyright 2013-2014 Enrico Marino / Jordan Harband
+ * @license MIT
+ */
+
+var objProto = Object.prototype;
+var owns = objProto.hasOwnProperty;
+var toStr = objProto.toString;
+var symbolValueOf;
+if (typeof Symbol === 'function') {
+ symbolValueOf = Symbol.prototype.valueOf;
+}
+var bigIntValueOf;
+if (typeof BigInt === 'function') {
+ bigIntValueOf = BigInt.prototype.valueOf;
+}
+var isActualNaN = function (value) {
+ return value !== value;
+};
+var NON_HOST_TYPES = {
+ 'boolean': 1,
+ number: 1,
+ string: 1,
+ undefined: 1
+};
+
+var base64Regex = /^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$/;
+var hexRegex = /^[A-Fa-f0-9]+$/;
+
+/**
+ * Expose `is`
+ */
+
+var is = {};
+
+/**
+ * Test general.
+ */
+
+/**
+ * is.type
+ * Test if `value` is a type of `type`.
+ *
+ * @param {*} value value to test
+ * @param {String} type type
+ * @return {Boolean} true if `value` is a type of `type`, false otherwise
+ * @api public
+ */
+
+is.a = is.type = function (value, type) {
+ return typeof value === type;
+};
+
+/**
+ * is.defined
+ * Test if `value` is defined.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if 'value' is defined, false otherwise
+ * @api public
+ */
+
+is.defined = function (value) {
+ return typeof value !== 'undefined';
+};
+
+/**
+ * is.empty
+ * Test if `value` is empty.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is empty, false otherwise
+ * @api public
+ */
+
+is.empty = function (value) {
+ var type = toStr.call(value);
+ var key;
+
+ if (type === '[object Array]' || type === '[object Arguments]' || type === '[object String]') {
+ return value.length === 0;
+ }
+
+ if (type === '[object Object]') {
+ for (key in value) {
+ if (owns.call(value, key)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ return !value;
+};
+
+/**
+ * is.equal
+ * Test if `value` is equal to `other`.
+ *
+ * @param {*} value value to test
+ * @param {*} other value to compare with
+ * @return {Boolean} true if `value` is equal to `other`, false otherwise
+ */
+
+is.equal = function equal(value, other) {
+ if (value === other) {
+ return true;
+ }
+
+ var type = toStr.call(value);
+ var key;
+
+ if (type !== toStr.call(other)) {
+ return false;
+ }
+
+ if (type === '[object Object]') {
+ for (key in value) {
+ if (!is.equal(value[key], other[key]) || !(key in other)) {
+ return false;
+ }
+ }
+ for (key in other) {
+ if (!is.equal(value[key], other[key]) || !(key in value)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ if (type === '[object Array]') {
+ key = value.length;
+ if (key !== other.length) {
+ return false;
+ }
+ while (key--) {
+ if (!is.equal(value[key], other[key])) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ if (type === '[object Function]') {
+ return value.prototype === other.prototype;
+ }
+
+ if (type === '[object Date]') {
+ return value.getTime() === other.getTime();
+ }
+
+ return false;
+};
+
+/**
+ * is.hosted
+ * Test if `value` is hosted by `host`.
+ *
+ * @param {*} value to test
+ * @param {*} host host to test with
+ * @return {Boolean} true if `value` is hosted by `host`, false otherwise
+ * @api public
+ */
+
+is.hosted = function (value, host) {
+ var type = typeof host[value];
+ return type === 'object' ? !!host[value] : !NON_HOST_TYPES[type];
+};
+
+/**
+ * is.instance
+ * Test if `value` is an instance of `constructor`.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is an instance of `constructor`
+ * @api public
+ */
+
+is.instance = is['instanceof'] = function (value, constructor) {
+ return value instanceof constructor;
+};
+
+/**
+ * is.nil / is.null
+ * Test if `value` is null.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is null, false otherwise
+ * @api public
+ */
+
+is.nil = is['null'] = function (value) {
+ return value === null;
+};
+
+/**
+ * is.undef / is.undefined
+ * Test if `value` is undefined.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is undefined, false otherwise
+ * @api public
+ */
+
+is.undef = is.undefined = function (value) {
+ return typeof value === 'undefined';
+};
+
+/**
+ * Test arguments.
+ */
+
+/**
+ * is.args
+ * Test if `value` is an arguments object.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is an arguments object, false otherwise
+ * @api public
+ */
+
+is.args = is.arguments = function (value) {
+ var isStandardArguments = toStr.call(value) === '[object Arguments]';
+ var isOldArguments = !is.array(value) && is.arraylike(value) && is.object(value) && is.fn(value.callee);
+ return isStandardArguments || isOldArguments;
+};
+
+/**
+ * Test array.
+ */
+
+/**
+ * is.array
+ * Test if 'value' is an array.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is an array, false otherwise
+ * @api public
+ */
+
+is.array = Array.isArray || function (value) {
+ return toStr.call(value) === '[object Array]';
+};
+
+/**
+ * is.arguments.empty
+ * Test if `value` is an empty arguments object.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is an empty arguments object, false otherwise
+ * @api public
+ */
+is.args.empty = function (value) {
+ return is.args(value) && value.length === 0;
+};
+
+/**
+ * is.array.empty
+ * Test if `value` is an empty array.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is an empty array, false otherwise
+ * @api public
+ */
+is.array.empty = function (value) {
+ return is.array(value) && value.length === 0;
+};
+
+/**
+ * is.arraylike
+ * Test if `value` is an arraylike object.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is an arguments object, false otherwise
+ * @api public
+ */
+
+is.arraylike = function (value) {
+ return !!value && !is.bool(value)
+ && owns.call(value, 'length')
+ && isFinite(value.length)
+ && is.number(value.length)
+ && value.length >= 0;
+};
+
+/**
+ * Test boolean.
+ */
+
+/**
+ * is.bool
+ * Test if `value` is a boolean.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is a boolean, false otherwise
+ * @api public
+ */
+
+is.bool = is['boolean'] = function (value) {
+ return toStr.call(value) === '[object Boolean]';
+};
+
+/**
+ * is.false
+ * Test if `value` is false.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is false, false otherwise
+ * @api public
+ */
+
+is['false'] = function (value) {
+ return is.bool(value) && Boolean(Number(value)) === false;
+};
+
+/**
+ * is.true
+ * Test if `value` is true.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is true, false otherwise
+ * @api public
+ */
+
+is['true'] = function (value) {
+ return is.bool(value) && Boolean(Number(value)) === true;
+};
+
+/**
+ * Test date.
+ */
+
+/**
+ * is.date
+ * Test if `value` is a date.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is a date, false otherwise
+ * @api public
+ */
+
+is.date = function (value) {
+ return toStr.call(value) === '[object Date]';
+};
+
+/**
+ * is.date.valid
+ * Test if `value` is a valid date.
+ *
+ * @param {*} value value to test
+ * @returns {Boolean} true if `value` is a valid date, false otherwise
+ */
+is.date.valid = function (value) {
+ return is.date(value) && !isNaN(Number(value));
+};
+
+/**
+ * Test element.
+ */
+
+/**
+ * is.element
+ * Test if `value` is an html element.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is an HTML Element, false otherwise
+ * @api public
+ */
+
+is.element = function (value) {
+ return value !== undefined
+ && typeof HTMLElement !== 'undefined'
+ && value instanceof HTMLElement
+ && value.nodeType === 1;
+};
+
+/**
+ * Test error.
+ */
+
+/**
+ * is.error
+ * Test if `value` is an error object.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is an error object, false otherwise
+ * @api public
+ */
+
+is.error = function (value) {
+ return toStr.call(value) === '[object Error]';
+};
+
+/**
+ * Test function.
+ */
+
+/**
+ * is.fn / is.function (deprecated)
+ * Test if `value` is a function.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is a function, false otherwise
+ * @api public
+ */
+
+is.fn = is['function'] = function (value) {
+ var isAlert = typeof window !== 'undefined' && value === window.alert;
+ if (isAlert) {
+ return true;
+ }
+ var str = toStr.call(value);
+ return str === '[object Function]' || str === '[object GeneratorFunction]' || str === '[object AsyncFunction]';
+};
+
+/**
+ * Test number.
+ */
+
+/**
+ * is.number
+ * Test if `value` is a number.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is a number, false otherwise
+ * @api public
+ */
+
+is.number = function (value) {
+ return toStr.call(value) === '[object Number]';
+};
+
+/**
+ * is.infinite
+ * Test if `value` is positive or negative infinity.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is positive or negative Infinity, false otherwise
+ * @api public
+ */
+is.infinite = function (value) {
+ return value === Infinity || value === -Infinity;
+};
+
+/**
+ * is.decimal
+ * Test if `value` is a decimal number.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is a decimal number, false otherwise
+ * @api public
+ */
+
+is.decimal = function (value) {
+ return is.number(value) && !isActualNaN(value) && !is.infinite(value) && value % 1 !== 0;
+};
+
+/**
+ * is.divisibleBy
+ * Test if `value` is divisible by `n`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} n dividend
+ * @return {Boolean} true if `value` is divisible by `n`, false otherwise
+ * @api public
+ */
+
+is.divisibleBy = function (value, n) {
+ var isDividendInfinite = is.infinite(value);
+ var isDivisorInfinite = is.infinite(n);
+ var isNonZeroNumber = is.number(value) && !isActualNaN(value) && is.number(n) && !isActualNaN(n) && n !== 0;
+ return isDividendInfinite || isDivisorInfinite || (isNonZeroNumber && value % n === 0);
+};
+
+/**
+ * is.integer
+ * Test if `value` is an integer.
+ *
+ * @param value to test
+ * @return {Boolean} true if `value` is an integer, false otherwise
+ * @api public
+ */
+
+is.integer = is['int'] = function (value) {
+ return is.number(value) && !isActualNaN(value) && value % 1 === 0;
+};
+
+/**
+ * is.maximum
+ * Test if `value` is greater than 'others' values.
+ *
+ * @param {Number} value value to test
+ * @param {Array} others values to compare with
+ * @return {Boolean} true if `value` is greater than `others` values
+ * @api public
+ */
+
+is.maximum = function (value, others) {
+ if (isActualNaN(value)) {
+ throw new TypeError('NaN is not a valid value');
+ } else if (!is.arraylike(others)) {
+ throw new TypeError('second argument must be array-like');
+ }
+ var len = others.length;
+
+ while (--len >= 0) {
+ if (value < others[len]) {
+ return false;
+ }
+ }
+
+ return true;
+};
+
+/**
+ * is.minimum
+ * Test if `value` is less than `others` values.
+ *
+ * @param {Number} value value to test
+ * @param {Array} others values to compare with
+ * @return {Boolean} true if `value` is less than `others` values
+ * @api public
+ */
+
+is.minimum = function (value, others) {
+ if (isActualNaN(value)) {
+ throw new TypeError('NaN is not a valid value');
+ } else if (!is.arraylike(others)) {
+ throw new TypeError('second argument must be array-like');
+ }
+ var len = others.length;
+
+ while (--len >= 0) {
+ if (value > others[len]) {
+ return false;
+ }
+ }
+
+ return true;
+};
+
+/**
+ * is.nan
+ * Test if `value` is not a number.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is not a number, false otherwise
+ * @api public
+ */
+
+is.nan = function (value) {
+ return !is.number(value) || value !== value;
+};
+
+/**
+ * is.even
+ * Test if `value` is an even number.
+ *
+ * @param {Number} value value to test
+ * @return {Boolean} true if `value` is an even number, false otherwise
+ * @api public
+ */
+
+is.even = function (value) {
+ return is.infinite(value) || (is.number(value) && value === value && value % 2 === 0);
+};
+
+/**
+ * is.odd
+ * Test if `value` is an odd number.
+ *
+ * @param {Number} value value to test
+ * @return {Boolean} true if `value` is an odd number, false otherwise
+ * @api public
+ */
+
+is.odd = function (value) {
+ return is.infinite(value) || (is.number(value) && value === value && value % 2 !== 0);
+};
+
+/**
+ * is.ge
+ * Test if `value` is greater than or equal to `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean}
+ * @api public
+ */
+
+is.ge = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value >= other;
+};
+
+/**
+ * is.gt
+ * Test if `value` is greater than `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean}
+ * @api public
+ */
+
+is.gt = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value > other;
+};
+
+/**
+ * is.le
+ * Test if `value` is less than or equal to `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean} if 'value' is less than or equal to 'other'
+ * @api public
+ */
+
+is.le = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value <= other;
+};
+
+/**
+ * is.lt
+ * Test if `value` is less than `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean} if `value` is less than `other`
+ * @api public
+ */
+
+is.lt = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value < other;
+};
+
+/**
+ * is.within
+ * Test if `value` is within `start` and `finish`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} start lower bound
+ * @param {Number} finish upper bound
+ * @return {Boolean} true if 'value' is is within 'start' and 'finish'
+ * @api public
+ */
+is.within = function (value, start, finish) {
+ if (isActualNaN(value) || isActualNaN(start) || isActualNaN(finish)) {
+ throw new TypeError('NaN is not a valid value');
+ } else if (!is.number(value) || !is.number(start) || !is.number(finish)) {
+ throw new TypeError('all arguments must be numbers');
+ }
+ var isAnyInfinite = is.infinite(value) || is.infinite(start) || is.infinite(finish);
+ return isAnyInfinite || (value >= start && value <= finish);
+};
+
+/**
+ * Test object.
+ */
+
+/**
+ * is.object
+ * Test if `value` is an object.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is an object, false otherwise
+ * @api public
+ */
+is.object = function (value) {
+ return toStr.call(value) === '[object Object]';
+};
+
+/**
+ * is.primitive
+ * Test if `value` is a primitive.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is a primitive, false otherwise
+ * @api public
+ */
+is.primitive = function isPrimitive(value) {
+ if (!value) {
+ return true;
+ }
+ if (typeof value === 'object' || is.object(value) || is.fn(value) || is.array(value)) {
+ return false;
+ }
+ return true;
+};
+
+/**
+ * is.hash
+ * Test if `value` is a hash - a plain object literal.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is a hash, false otherwise
+ * @api public
+ */
+
+is.hash = function (value) {
+ return is.object(value) && value.constructor === Object && !value.nodeType && !value.setInterval;
+};
+
+/**
+ * Test regexp.
+ */
+
+/**
+ * is.regexp
+ * Test if `value` is a regular expression.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is a regexp, false otherwise
+ * @api public
+ */
+
+is.regexp = function (value) {
+ return toStr.call(value) === '[object RegExp]';
+};
+
+/**
+ * Test string.
+ */
+
+/**
+ * is.string
+ * Test if `value` is a string.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if 'value' is a string, false otherwise
+ * @api public
+ */
+
+is.string = function (value) {
+ return toStr.call(value) === '[object String]';
+};
+
+/**
+ * Test base64 string.
+ */
+
+/**
+ * is.base64
+ * Test if `value` is a valid base64 encoded string.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if 'value' is a base64 encoded string, false otherwise
+ * @api public
+ */
+
+is.base64 = function (value) {
+ return is.string(value) && (!value.length || base64Regex.test(value));
+};
+
+/**
+ * Test base64 string.
+ */
+
+/**
+ * is.hex
+ * Test if `value` is a valid hex encoded string.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if 'value' is a hex encoded string, false otherwise
+ * @api public
+ */
+
+is.hex = function (value) {
+ return is.string(value) && (!value.length || hexRegex.test(value));
+};
+
+/**
+ * is.symbol
+ * Test if `value` is an ES6 Symbol
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is a Symbol, false otherise
+ * @api public
+ */
+
+is.symbol = function (value) {
+ return typeof Symbol === 'function' && toStr.call(value) === '[object Symbol]' && typeof symbolValueOf.call(value) === 'symbol';
+};
+
+/**
+ * is.bigint
+ * Test if `value` is an ES-proposed BigInt
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is a BigInt, false otherise
+ * @api public
+ */
+
+is.bigint = function (value) {
+ // eslint-disable-next-line valid-typeof
+ return typeof BigInt === 'function' && toStr.call(value) === '[object BigInt]' && typeof bigIntValueOf.call(value) === 'bigint';
+};
+
+module.exports = is;
+
+},{}],67:[function(require,module,exports){
+(function (global){(function (){
+/*! JSON v3.3.2 | https://bestiejs.github.io/json3 | Copyright 2012-2015, Kit Cambridge, Benjamin Tan | 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 = objectProto.hasOwnProperty,
+ undefined;
+
+ // Internal: Contains `try...catch` logic used by other functions.
+ // This prevents other functions from being deoptimized.
+ function attempt(func, errorFunc) {
+ try {
+ func();
+ } catch (exception) {
+ if (errorFunc) {
+ errorFunc();
+ }
+ }
+ }
+
+ // Test the `Date#getUTC*` methods. Based on work by @Yaffle.
+ var isExtended = new Date(-3509827334573292);
+ attempt(function () {
+ // 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 &&
+ isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708;
+ });
+
+ // 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] != null) {
+ // 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("date-serialization") && has("json-parse");
+ } else if (name == "date-serialization") {
+ // Indicates whether `Date`s can be serialized accurately by `JSON.stringify`.
+ isSupported = has("json-stringify") && isExtended;
+ if (isSupported) {
+ var stringify = exports.stringify;
+ attempt(function () {
+ isSupported =
+ // 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"';
+ });
+ }
+ } 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";
+ if (stringifySupported) {
+ // A test function object with a custom `toJSON` method.
+ (value = function () {
+ return 1;
+ }).toJSON = value;
+ attempt(function () {
+ 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) === undefined &&
+ // IE 8 serializes `undefined` as `"undefined"`. Safari <= 5.1.7 and
+ // FF 3.1b3 pass this test.
+ stringify(undefined) === undefined &&
+ // Safari <= 5.1.7 and FF 3.1b3 throw `Error`s and `TypeError`s,
+ // respectively, if the value is omitted entirely.
+ stringify() === undefined &&
+ // 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([undefined]) == "[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([undefined, 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]";
+ }, function () {
+ stringifySupported = false;
+ });
+ }
+ isSupported = stringifySupported;
+ }
+ // Test `JSON.parse`.
+ if (name == "json-parse") {
+ var parse = exports.parse, parseSupported;
+ if (typeof parse == "function") {
+ attempt(function () {
+ // 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);
+ parseSupported = value["a"].length == 5 && value["a"][0] === 1;
+ if (parseSupported) {
+ attempt(function () {
+ // Safari <= 5.1.2 and FF 3.1b1 allow unescaped tabs in strings.
+ parseSupported = !parse('"\t"');
+ });
+ if (parseSupported) {
+ attempt(function () {
+ // 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;
+ });
+ }
+ if (parseSupported) {
+ attempt(function () {
+ // 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;
+ });
+ }
+ }
+ }
+ }, function () {
+ parseSupported = false;
+ });
+ }
+ isSupported = parseSupported;
+ }
+ }
+ return has[name] = !!isSupported;
+ }
+ has["bug-string-char-index"] = has["date-serialization"] = has["json"] = has["json-stringify"] = has["json-parse"] = null;
+
+ 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");
+
+ // Internal: Normalizes the `for...in` iteration algorithm across
+ // environments. Each enumerated key is yielded to a `callback` function.
+ var forOwn = function (object, callback) {
+ var size = 0, Properties, dontEnums, 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.
+ dontEnums = new Properties();
+ for (property in dontEnums) {
+ // Ignore all properties inherited from `Object.prototype`.
+ if (isProperty.call(dontEnums, property)) {
+ size++;
+ }
+ }
+ Properties = dontEnums = null;
+
+ // Normalize the iteration algorithm.
+ if (!size) {
+ // A list of non-enumerable properties inherited from `Object.prototype`.
+ dontEnums = ["valueOf", "toString", "toLocaleString", "propertyIsEnumerable", "isPrototypeOf", "hasOwnProperty", "constructor"];
+ // IE <= 8, Mozilla 1.0, and Netscape 6.2 ignore shadowed non-enumerable
+ // properties.
+ forOwn = 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 = dontEnums.length; property = dontEnums[--length];) {
+ if (hasProperty.call(object, property)) {
+ callback(property);
+ }
+ }
+ };
+ } else {
+ // No bugs detected; use the standard `for...in` algorithm.
+ forOwn = 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 forOwn(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") && !has("date-serialization")) {
+ // 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: Serializes a date object.
+ var serializeDate = function (value) {
+ var getData, year, month, date, time, hours, minutes, seconds, milliseconds;
+ // 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);
+ };
+ getData = function (value) {
+ // 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 {
+ getData = function (value) {
+ year = value.getUTCFullYear();
+ month = value.getUTCMonth();
+ date = value.getUTCDate();
+ hours = value.getUTCHours();
+ minutes = value.getUTCMinutes();
+ seconds = value.getUTCSeconds();
+ milliseconds = value.getUTCMilliseconds();
+ };
+ }
+ serializeDate = function (value) {
+ 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.
+ getData(value);
+ // 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";
+ year = month = date = hours = minutes = seconds = milliseconds = null;
+ } else {
+ value = null;
+ }
+ return value;
+ };
+ return serializeDate(value);
+ };
+
+ // For environments with `JSON.stringify` but buggy date serialization,
+ // we override the native `Date#toJSON` implementation with a
+ // spec-compliant one.
+ if (has("json-stringify") && !has("date-serialization")) {
+ // Internal: the `Date#toJSON` implementation used to override the native one.
+ function dateToJSON (key) {
+ return serializeDate(this);
+ }
+
+ // Public: `JSON.stringify`. See ES 5.1 section 15.12.3.
+ var nativeStringify = exports.stringify;
+ exports.stringify = function (source, filter, width) {
+ var nativeToJSON = Date.prototype.toJSON;
+ Date.prototype.toJSON = dateToJSON;
+ var result = nativeStringify(source, filter, width);
+ Date.prototype.toJSON = nativeToJSON;
+ return result;
+ }
+ } else {
+ // 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 escapeChar = function (character) {
+ var charCode = character.charCodeAt(0), escaped = Escapes[charCode];
+ if (escaped) {
+ return escaped;
+ }
+ return unicodePrefix + toPaddedString(2, charCode.toString(16));
+ };
+ var reEscape = /[\x00-\x1f\x22\x5c]/g;
+ var quote = function (value) {
+ reEscape.lastIndex = 0;
+ return '"' +
+ (
+ reEscape.test(value)
+ ? value.replace(reEscape, escapeChar)
+ : value
+ ) +
+ '"';
+ };
+
+ // 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, type, className, results, element, index, length, prefix, result;
+ attempt(function () {
+ // Necessary for host object support.
+ value = object[property];
+ });
+ if (typeof value == "object" && value) {
+ if (value.getUTCFullYear && getClass.call(value) == dateClass && value.toJSON === Date.prototype.toJSON) {
+ value = serializeDate(value);
+ } else if (typeof value.toJSON == "function") {
+ 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);
+ }
+ // Exit early if value is `undefined` or `null`.
+ if (value == undefined) {
+ return value === undefined ? value : "null";
+ }
+ type = typeof value;
+ // Only call `getClass` if the value is an object.
+ if (type == "object") {
+ className = getClass.call(value);
+ }
+ switch (className || type) {
+ case "boolean":
+ case booleanClass:
+ // Booleans are represented literally.
+ return "" + value;
+ case "number":
+ case numberClass:
+ // JSON numbers must be finite. `Infinity` and `NaN` are serialized as
+ // `"null"`.
+ return value > -1 / 0 && value < 1 / 0 ? "" + value : "null";
+ case "string":
+ case 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 === undefined ? "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.
+ forOwn(properties || value, function (property) {
+ var element = serialize(property, value, callback, properties, whitespace, indentation, stack);
+ if (element !== undefined) {
+ // 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) {
+ className = getClass.call(filter);
+ if (className == 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);
+ if (className == "[object String]" || className == "[object Number]") {
+ properties[value] = 1;
+ }
+ }
+ }
+ }
+ if (width) {
+ className = getClass.call(width);
+ if (className == numberClass) {
+ // Convert the `width` to an integer and create a string containing
+ // `width` number of space characters.
+ if ((width -= width % 1) > 0) {
+ if (width > 10) {
+ width = 10;
+ }
+ for (whitespace = ""; 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; position++) {
+ charCode = source.charCodeAt(position);
+ if (charCode < 48 || charCode > 57) {
+ break;
+ }
+ }
+ 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; position++) {
+ charCode = source.charCodeAt(position);
+ if (charCode < 48 || charCode > 57) {
+ break;
+ }
+ }
+ 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.
+ var temp = source.slice(Index, Index + 4);
+ if (temp == "true") {
+ Index += 4;
+ return true;
+ } else if (temp == "fals" && source.charCodeAt(Index + 4 ) == 101) {
+ Index += 5;
+ return false;
+ } else if (temp == "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 (;;) {
+ 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();
+ }
+ } else {
+ hasMembers = true;
+ }
+ // 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 (;;) {
+ 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();
+ }
+ } else {
+ hasMembers = true;
+ }
+ // 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 === undefined) {
+ 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) {
+ // `forOwn` 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(getClass, forOwn, value, length, callback);
+ }
+ } else {
+ forOwn(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)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],68:[function(require,module,exports){
+/**
+ * Module dependencies
+ */
+
+var debug = require('debug')('jsonp');
+
+/**
+ * Module exports.
+ */
+
+module.exports = jsonp;
+
+/**
+ * Callback index.
+ */
+
+var count = 0;
+
+/**
+ * Noop function.
+ */
+
+function noop(){}
+
+/**
+ * JSONP handler
+ *
+ * Options:
+ * - param {String} qs parameter (`callback`)
+ * - prefix {String} qs parameter (`__jp`)
+ * - name {String} qs parameter (`prefix` + incr)
+ * - timeout {Number} how long after a timeout error is emitted (`60000`)
+ *
+ * @param {String} url
+ * @param {Object|Function} optional options / callback
+ * @param {Function} optional callback
+ */
+
+function jsonp(url, opts, fn){
+ if ('function' == typeof opts) {
+ fn = opts;
+ opts = {};
+ }
+ if (!opts) opts = {};
+
+ var prefix = opts.prefix || '__jp';
+
+ // use the callback name that was passed if one was provided.
+ // otherwise generate a unique name by incrementing our counter.
+ var id = opts.name || (prefix + (count++));
+
+ var param = opts.param || 'callback';
+ var timeout = null != opts.timeout ? opts.timeout : 60000;
+ var enc = encodeURIComponent;
+ var target = document.getElementsByTagName('script')[0] || document.head;
+ var script;
+ var timer;
+
+
+ if (timeout) {
+ timer = setTimeout(function(){
+ cleanup();
+ if (fn) fn(new Error('Timeout'));
+ }, timeout);
+ }
+
+ function cleanup(){
+ if (script.parentNode) script.parentNode.removeChild(script);
+ window[id] = noop;
+ if (timer) clearTimeout(timer);
+ }
+
+ function cancel(){
+ if (window[id]) {
+ cleanup();
+ }
+ }
+
+ window[id] = function(data){
+ debug('jsonp got', data);
+ cleanup();
+ if (fn) fn(null, data);
+ };
+
+ // add qs component
+ url += (~url.indexOf('?') ? '&' : '?') + param + '=' + enc(id);
+ url = url.replace('?&', '?');
+
+ debug('jsonp req "%s"', url);
+
+ // create script
+ script = document.createElement('script');
+ script.src = url;
+ target.parentNode.insertBefore(script, target);
+
+ return cancel;
+}
+
+},{"debug":59}],69:[function(require,module,exports){
+/**
+ * Module dependencies.
+ */
+
+var is = require('is');
+var onload = require('script-onload');
+var tick = require('next-tick');
+
+/**
+ * Expose `loadScript`.
+ *
+ * @param {Object} options
+ * @param {Function} fn
+ * @api public
+ */
+
+module.exports = function loadIframe(options, fn){
+ if (!options) throw new Error('Cant load nothing...');
+
+ // Allow for the simplest case, just passing a `src` string.
+ if (is.string(options)) options = { src : options };
+
+ var https = document.location.protocol === 'https:' ||
+ document.location.protocol === 'chrome-extension:';
+
+ // If you use protocol relative URLs, third-party scripts like Google
+ // Analytics break when testing with `file:` so this fixes that.
+ if (options.src && options.src.indexOf('//') === 0) {
+ options.src = https ? 'https:' + options.src : 'http:' + options.src;
+ }
+
+ // Allow them to pass in different URLs depending on the protocol.
+ if (https && options.https) options.src = options.https;
+ else if (!https && options.http) options.src = options.http;
+
+ // Make the `<iframe>` element and insert it before the first iframe on the
+ // page, which is guaranteed to exist since this Javaiframe is running.
+ var iframe = document.createElement('iframe');
+ iframe.src = options.src;
+ iframe.width = options.width || 1;
+ iframe.height = options.height || 1;
+ iframe.style.display = 'none';
+
+ // If we have a fn, attach event handlers, even in IE. Based off of
+ // the Third-Party Javascript script loading example:
+ // https://github.com/thirdpartyjs/thirdpartyjs-code/blob/master/examples/templates/02/loading-files/index.html
+ if (is.fn(fn)) {
+ onload(iframe, fn);
+ }
+
+ tick(function(){
+ // Append after event listeners are attached for IE.
+ var firstScript = document.getElementsByTagName('script')[0];
+ firstScript.parentNode.insertBefore(iframe, firstScript);
+ });
+
+ // Return the iframe element in case they want to do anything special, like
+ // give it an ID or attributes.
+ return iframe;
+};
+
+},{"is":66,"next-tick":76,"script-onload":79}],70:[function(require,module,exports){
+(function (global){(function (){
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER = 9007199254740991;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+ arrayTag = '[object Array]',
+ boolTag = '[object Boolean]',
+ dateTag = '[object Date]',
+ errorTag = '[object Error]',
+ funcTag = '[object Function]',
+ genTag = '[object GeneratorFunction]',
+ mapTag = '[object Map]',
+ numberTag = '[object Number]',
+ objectTag = '[object Object]',
+ promiseTag = '[object Promise]',
+ regexpTag = '[object RegExp]',
+ setTag = '[object Set]',
+ stringTag = '[object String]',
+ symbolTag = '[object Symbol]',
+ weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+ dataViewTag = '[object DataView]',
+ 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 match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to match `RegExp` flags from their coerced string values. */
+var reFlags = /\w*$/;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** Used to detect unsigned integer values. */
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+/** Used to identify `toStringTag` values supported by `_.clone`. */
+var cloneableTags = {};
+cloneableTags[argsTag] = cloneableTags[arrayTag] =
+cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
+cloneableTags[boolTag] = cloneableTags[dateTag] =
+cloneableTags[float32Tag] = cloneableTags[float64Tag] =
+cloneableTags[int8Tag] = cloneableTags[int16Tag] =
+cloneableTags[int32Tag] = cloneableTags[mapTag] =
+cloneableTags[numberTag] = cloneableTags[objectTag] =
+cloneableTags[regexpTag] = cloneableTags[setTag] =
+cloneableTags[stringTag] = cloneableTags[symbolTag] =
+cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag] = cloneableTags[funcTag] =
+cloneableTags[weakMapTag] = false;
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+
+/** Detect free variable `exports`. */
+var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/**
+ * Adds the key-value `pair` to `map`.
+ *
+ * @private
+ * @param {Object} map The map to modify.
+ * @param {Array} pair The key-value pair to add.
+ * @returns {Object} Returns `map`.
+ */
+function addMapEntry(map, pair) {
+ // Don't return `map.set` because it's not chainable in IE 11.
+ map.set(pair[0], pair[1]);
+ return map;
+}
+
+/**
+ * Adds `value` to `set`.
+ *
+ * @private
+ * @param {Object} set The set to modify.
+ * @param {*} value The value to add.
+ * @returns {Object} Returns `set`.
+ */
+function addSetEntry(set, value) {
+ // Don't return `set.add` because it's not chainable in IE 11.
+ set.add(value);
+ return set;
+}
+
+/**
+ * A specialized version of `_.forEach` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @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 ? array.length : 0;
+
+ while (++index < length) {
+ if (iteratee(array[index], index, array) === false) {
+ break;
+ }
+ }
+ return array;
+}
+
+/**
+ * Appends the elements of `values` to `array`.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to append.
+ * @returns {Array} Returns `array`.
+ */
+function arrayPush(array, values) {
+ var index = -1,
+ length = values.length,
+ offset = array.length;
+
+ while (++index < length) {
+ array[offset + index] = values[index];
+ }
+ return array;
+}
+
+/**
+ * A specialized version of `_.reduce` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @param {boolean} [initAccum] Specify using the first element of `array` as
+ * the initial value.
+ * @returns {*} Returns the accumulated value.
+ */
+function arrayReduce(array, iteratee, accumulator, initAccum) {
+ var index = -1,
+ length = array ? array.length : 0;
+
+ if (initAccum && length) {
+ accumulator = array[++index];
+ }
+ while (++index < length) {
+ accumulator = iteratee(accumulator, array[index], index, array);
+ }
+ return accumulator;
+}
+
+/**
+ * The base implementation of `_.times` without support for iteratee shorthands
+ * or max array length checks.
+ *
+ * @private
+ * @param {number} n The number of times to invoke `iteratee`.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the array of results.
+ */
+function baseTimes(n, iteratee) {
+ var index = -1,
+ result = Array(n);
+
+ while (++index < n) {
+ result[index] = iteratee(index);
+ }
+ return result;
+}
+
+/**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function getValue(object, key) {
+ return object == null ? undefined : object[key];
+}
+
+/**
+ * Checks if `value` is a host object in IE < 9.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+ */
+function isHostObject(value) {
+ // Many host objects are `Object` objects that can coerce to strings
+ // despite having improperly defined `toString` methods.
+ var result = false;
+ if (value != null && typeof value.toString != 'function') {
+ try {
+ result = !!(value + '');
+ } catch (e) {}
+ }
+ return result;
+}
+
+/**
+ * Converts `map` to its key-value pairs.
+ *
+ * @private
+ * @param {Object} map The map to convert.
+ * @returns {Array} Returns the key-value pairs.
+ */
+function mapToArray(map) {
+ var index = -1,
+ result = Array(map.size);
+
+ map.forEach(function(value, key) {
+ result[++index] = [key, value];
+ });
+ return result;
+}
+
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg(func, transform) {
+ return function(arg) {
+ return func(transform(arg));
+ };
+}
+
+/**
+ * Converts `set` to an array of its values.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the values.
+ */
+function setToArray(set) {
+ var index = -1,
+ result = Array(set.size);
+
+ set.forEach(function(value) {
+ result[++index] = value;
+ });
+ return result;
+}
+
+/** Used for built-in method references. */
+var arrayProto = Array.prototype,
+ funcProto = Function.prototype,
+ objectProto = Object.prototype;
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData = root['__core-js_shared__'];
+
+/** Used to detect methods masquerading as native. */
+var maskSrcKey = (function() {
+ var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+ return uid ? ('Symbol(src)_1.' + uid) : '';
+}());
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/** Used to detect if a method is native. */
+var reIsNative = RegExp('^' +
+ funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+ .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+);
+
+/** Built-in value references. */
+var Buffer = moduleExports ? root.Buffer : undefined,
+ Symbol = root.Symbol,
+ Uint8Array = root.Uint8Array,
+ getPrototype = overArg(Object.getPrototypeOf, Object),
+ objectCreate = Object.create,
+ propertyIsEnumerable = objectProto.propertyIsEnumerable,
+ splice = arrayProto.splice;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeGetSymbols = Object.getOwnPropertySymbols,
+ nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
+ nativeKeys = overArg(Object.keys, Object);
+
+/* Built-in method references that are verified to be native. */
+var DataView = getNative(root, 'DataView'),
+ Map = getNative(root, 'Map'),
+ Promise = getNative(root, 'Promise'),
+ Set = getNative(root, 'Set'),
+ WeakMap = getNative(root, 'WeakMap'),
+ nativeCreate = getNative(Object, 'create');
+
+/** Used to detect maps, sets, and weakmaps. */
+var dataViewCtorString = toSource(DataView),
+ mapCtorString = toSource(Map),
+ promiseCtorString = toSource(Promise),
+ setCtorString = toSource(Set),
+ weakMapCtorString = toSource(WeakMap);
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+ symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash(entries) {
+ var index = -1,
+ length = entries ? entries.length : 0;
+
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+}
+
+/**
+ * Removes all key-value entries from the hash.
+ *
+ * @private
+ * @name clear
+ * @memberOf Hash
+ */
+function hashClear() {
+ this.__data__ = nativeCreate ? nativeCreate(null) : {};
+}
+
+/**
+ * Removes `key` and its value from the hash.
+ *
+ * @private
+ * @name delete
+ * @memberOf Hash
+ * @param {Object} hash The hash to modify.
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function hashDelete(key) {
+ return this.has(key) && delete this.__data__[key];
+}
+
+/**
+ * Gets the hash value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Hash
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function hashGet(key) {
+ var data = this.__data__;
+ if (nativeCreate) {
+ var result = data[key];
+ return result === HASH_UNDEFINED ? undefined : result;
+ }
+ return hasOwnProperty.call(data, key) ? data[key] : undefined;
... 7502 lines suppressed ...