(function webpackUniversalModuleDefinition(root, factory) {

if(typeof exports === 'object' && typeof module === 'object')
        module.exports = factory();
else if(typeof define === 'function' && define.amd)
        define([], factory);
else if(typeof exports === 'object')
        exports["mermaid"] = factory();
else
        root["mermaid"] = factory();

})(this, function() { return /******/ (function(modules) { // webpackBootstrap /******/ // The module cache /******/ var installedModules = {}; /******/ /******/ // The require function /******/ function webpack_require(moduleId) { /******/ /******/ // Check if module is in cache /******/ if(installedModules) { /******/ return installedModules.exports; /******/ } /******/ // Create a new module (and put it into the cache) /******/ var module = installedModules = { /******/ i: moduleId, /******/ l: false, /******/ exports: {} /******/ }; /******/ /******/ // Execute the module function /******/ modules.call(module.exports, module, module.exports, webpack_require); /******/ /******/ // Flag the module as loaded /******/ module.l = true; /******/ /******/ // Return the exports of the module /******/ return module.exports; /******/ } /******/ /******/ /******/ // expose the modules object (webpack_modules) /******/ webpack_require.m = modules; /******/ /******/ // expose the module cache /******/ webpack_require.c = installedModules; /******/ /******/ // define getter function for harmony exports /******/ webpack_require.d = function(exports, name, getter) { /******/ if(!webpack_require.o(exports, name)) { /******/ Object.defineProperty(exports, name, { /******/ configurable: false, /******/ enumerable: true, /******/ get: getter /******/ }); /******/ } /******/ }; /******/ /******/ // getDefaultExport function for compatibility with non-harmony modules /******/ webpack_require.n = function(module) { /******/ var getter = module && module.__esModule ? /******/ function getDefault() { return module; } : /******/ function getModuleExports() { return module; }; /******/ webpack_require.d(getter, 'a', getter); /******/ return getter; /******/ }; /******/ /******/ // Object.prototype.hasOwnProperty.call /******/ webpack_require.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; /******/ /******/ // webpack_public_path /******/ webpack_require.p = “”; /******/ /******/ // Load entry module and return exports /******/ return webpack_require(_webpack_require_.s = 199); /******/ }) /************************************************************************/ /******/ ([ /* 0 */ /***/ (function(module, exports, webpack_require) {

/* WEBPACK VAR INJECTION */(function(module) {//! moment.js //! version : 2.18.1 //! authors : Tim Wood, Iskren Chernev, Moment.js contributors //! license : MIT //! momentjs.com

;(function (global, factory) {

 true ? module.exports = factory() :
typeof define === 'function' && define.amd ? define(factory) :
global.moment = factory()

}(this, (function () { 'use strict';

var hookCallback;

function hooks () {

return hookCallback.apply(null, arguments);

}

// This is done to register the method called with moment() // without creating circular dependencies. function setHookCallback (callback) {

hookCallback = callback;

}

function isArray(input) {

return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';

}

function isObject(input) {

// IE8 will treat undefined and null as object if it wasn't for
// input != null
return input != null && Object.prototype.toString.call(input) === '[object Object]';

}

function isObjectEmpty(obj) {

var k;
for (k in obj) {
    // even if its not own property I'd still call it non-empty
    return false;
}
return true;

}

function isUndefined(input) {

return input === void 0;

}

function isNumber(input) {

return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';

}

function isDate(input) {

return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';

}

function map(arr, fn) {

var res = [], i;
for (i = 0; i < arr.length; ++i) {
    res.push(fn(arr[i], i));
}
return res;

}

function hasOwnProp(a, b) {

return Object.prototype.hasOwnProperty.call(a, b);

}

function extend(a, b) {

for (var i in b) {
    if (hasOwnProp(b, i)) {
        a[i] = b[i];
    }
}

if (hasOwnProp(b, 'toString')) {
    a.toString = b.toString;
}

if (hasOwnProp(b, 'valueOf')) {
    a.valueOf = b.valueOf;
}

return a;

}

function createUTC (input, format, locale, strict) {

return createLocalOrUTC(input, format, locale, strict, true).utc();

}

function defaultParsingFlags() {

// We need to deep clone this object.
return {
    empty           : false,
    unusedTokens    : [],
    unusedInput     : [],
    overflow        : -2,
    charsLeftOver   : 0,
    nullInput       : false,
    invalidMonth    : null,
    invalidFormat   : false,
    userInvalidated : false,
    iso             : false,
    parsedDateParts : [],
    meridiem        : null,
    rfc2822         : false,
    weekdayMismatch : false
};

}

function getParsingFlags(m) {

if (m._pf == null) {
    m._pf = defaultParsingFlags();
}
return m._pf;

}

var some; if (Array.prototype.some) {

some = Array.prototype.some;

} else {

some = function (fun) {
    var t = Object(this);
    var len = t.length >>> 0;

    for (var i = 0; i < len; i++) {
        if (i in t && fun.call(this, t[i], i, t)) {
            return true;
        }
    }

    return false;
};

}

var some$1 = some;

function isValid(m) {

if (m._isValid == null) {
    var flags = getParsingFlags(m);
    var parsedParts = some$1.call(flags.parsedDateParts, function (i) {
        return i != null;
    });
    var isNowValid = !isNaN(m._d.getTime()) &&
        flags.overflow < 0 &&
        !flags.empty &&
        !flags.invalidMonth &&
        !flags.invalidWeekday &&
        !flags.nullInput &&
        !flags.invalidFormat &&
        !flags.userInvalidated &&
        (!flags.meridiem || (flags.meridiem && parsedParts));

    if (m._strict) {
        isNowValid = isNowValid &&
            flags.charsLeftOver === 0 &&
            flags.unusedTokens.length === 0 &&
            flags.bigHour === undefined;
    }

    if (Object.isFrozen == null || !Object.isFrozen(m)) {
        m._isValid = isNowValid;
    }
    else {
        return isNowValid;
    }
}
return m._isValid;

}

function createInvalid (flags) {

var m = createUTC(NaN);
if (flags != null) {
    extend(getParsingFlags(m), flags);
}
else {
    getParsingFlags(m).userInvalidated = true;
}

return m;

}

// Plugins that add properties should also add the key here (null value), // so we can properly clone ourselves. var momentProperties = hooks.momentProperties = [];

function copyConfig(to, from) {

var i, prop, val;

if (!isUndefined(from._isAMomentObject)) {
    to._isAMomentObject = from._isAMomentObject;
}
if (!isUndefined(from._i)) {
    to._i = from._i;
}
if (!isUndefined(from._f)) {
    to._f = from._f;
}
if (!isUndefined(from._l)) {
    to._l = from._l;
}
if (!isUndefined(from._strict)) {
    to._strict = from._strict;
}
if (!isUndefined(from._tzm)) {
    to._tzm = from._tzm;
}
if (!isUndefined(from._isUTC)) {
    to._isUTC = from._isUTC;
}
if (!isUndefined(from._offset)) {
    to._offset = from._offset;
}
if (!isUndefined(from._pf)) {
    to._pf = getParsingFlags(from);
}
if (!isUndefined(from._locale)) {
    to._locale = from._locale;
}

if (momentProperties.length > 0) {
    for (i = 0; i < momentProperties.length; i++) {
        prop = momentProperties[i];
        val = from[prop];
        if (!isUndefined(val)) {
            to[prop] = val;
        }
    }
}

return to;

}

var updateInProgress = false;

// Moment prototype object function Moment(config) {

copyConfig(this, config);
this._d = new Date(config._d != null ? config._d.getTime() : NaN);
if (!this.isValid()) {
    this._d = new Date(NaN);
}
// Prevent infinite loop in case updateOffset creates new moment
// objects.
if (updateInProgress === false) {
    updateInProgress = true;
    hooks.updateOffset(this);
    updateInProgress = false;
}

}

function isMoment (obj) {

return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);

}

function absFloor (number) {

if (number < 0) {
    // -0 -> 0
    return Math.ceil(number) || 0;
} else {
    return Math.floor(number);
}

}

function toInt(argumentForCoercion) {

var coercedNumber = +argumentForCoercion,
    value = 0;

if (coercedNumber !== 0 && isFinite(coercedNumber)) {
    value = absFloor(coercedNumber);
}

return value;

}

// compare two arrays, return the number of differences function compareArrays(array1, array2, dontConvert) {

var len = Math.min(array1.length, array2.length),
    lengthDiff = Math.abs(array1.length - array2.length),
    diffs = 0,
    i;
for (i = 0; i < len; i++) {
    if ((dontConvert && array1[i] !== array2[i]) ||
        (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
        diffs++;
    }
}
return diffs + lengthDiff;

}

function warn(msg) {

if (hooks.suppressDeprecationWarnings === false &&
        (typeof console !==  'undefined') && console.warn) {
    console.warn('Deprecation warning: ' + msg);
}

}

function deprecate(msg, fn) {

var firstTime = true;

return extend(function () {
    if (hooks.deprecationHandler != null) {
        hooks.deprecationHandler(null, msg);
    }
    if (firstTime) {
        var args = [];
        var arg;
        for (var i = 0; i < arguments.length; i++) {
            arg = '';
            if (typeof arguments[i] === 'object') {
                arg += '\n[' + i + '] ';
                for (var key in arguments[0]) {
                    arg += key + ': ' + arguments[0][key] + ', ';
                }
                arg = arg.slice(0, -2); // Remove trailing comma and space
            } else {
                arg = arguments[i];
            }
            args.push(arg);
        }
        warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack);
        firstTime = false;
    }
    return fn.apply(this, arguments);
}, fn);

}

var deprecations = {};

function deprecateSimple(name, msg) {

if (hooks.deprecationHandler != null) {
    hooks.deprecationHandler(name, msg);
}
if (!deprecations[name]) {
    warn(msg);
    deprecations[name] = true;
}

}

hooks.suppressDeprecationWarnings = false; hooks.deprecationHandler = null;

function isFunction(input) {

return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';

}

function set (config) {

var prop, i;
for (i in config) {
    prop = config[i];
    if (isFunction(prop)) {
        this[i] = prop;
    } else {
        this['_' + i] = prop;
    }
}
this._config = config;
// Lenient ordinal parsing accepts just a number in addition to
// number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
// TODO: Remove "ordinalParse" fallback in next major release.
this._dayOfMonthOrdinalParseLenient = new RegExp(
    (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
        '|' + (/\d{1,2}/).source);

}

function mergeConfigs(parentConfig, childConfig) {

var res = extend({}, parentConfig), prop;
for (prop in childConfig) {
    if (hasOwnProp(childConfig, prop)) {
        if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
            res[prop] = {};
            extend(res[prop], parentConfig[prop]);
            extend(res[prop], childConfig[prop]);
        } else if (childConfig[prop] != null) {
            res[prop] = childConfig[prop];
        } else {
            delete res[prop];
        }
    }
}
for (prop in parentConfig) {
    if (hasOwnProp(parentConfig, prop) &&
            !hasOwnProp(childConfig, prop) &&
            isObject(parentConfig[prop])) {
        // make sure changes to properties don't modify parent config
        res[prop] = extend({}, res[prop]);
    }
}
return res;

}

function Locale(config) {

if (config != null) {
    this.set(config);
}

}

var keys;

if (Object.keys) {

keys = Object.keys;

} else {

keys = function (obj) {
    var i, res = [];
    for (i in obj) {
        if (hasOwnProp(obj, i)) {
            res.push(i);
        }
    }
    return res;
};

}

var keys$1 = keys;

var defaultCalendar = {

sameDay : '[Today at] LT',
nextDay : '[Tomorrow at] LT',
nextWeek : 'dddd [at] LT',
lastDay : '[Yesterday at] LT',
lastWeek : '[Last] dddd [at] LT',
sameElse : 'L'

};

function calendar (key, mom, now) {

var output = this._calendar[key] || this._calendar['sameElse'];
return isFunction(output) ? output.call(mom, now) : output;

}

var defaultLongDateFormat = {

LTS  : 'h:mm:ss A',
LT   : 'h:mm A',
L    : 'MM/DD/YYYY',
LL   : 'MMMM D, YYYY',
LLL  : 'MMMM D, YYYY h:mm A',
LLLL : 'dddd, MMMM D, YYYY h:mm A'

};

function longDateFormat (key) {

var format = this._longDateFormat[key],
    formatUpper = this._longDateFormat[key.toUpperCase()];

if (format || !formatUpper) {
    return format;
}

this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
    return val.slice(1);
});

return this._longDateFormat[key];

}

var defaultInvalidDate = 'Invalid date';

function invalidDate () {

return this._invalidDate;

}

var defaultOrdinal = '%d'; var defaultDayOfMonthOrdinalParse = /d{1,2}/;

function ordinal (number) {

return this._ordinal.replace('%d', number);

}

var defaultRelativeTime = {

future : 'in %s',
past   : '%s ago',
s  : 'a few seconds',
ss : '%d seconds',
m  : 'a minute',
mm : '%d minutes',
h  : 'an hour',
hh : '%d hours',
d  : 'a day',
dd : '%d days',
M  : 'a month',
MM : '%d months',
y  : 'a year',
yy : '%d years'

};

function relativeTime (number, withoutSuffix, string, isFuture) {

var output = this._relativeTime[string];
return (isFunction(output)) ?
    output(number, withoutSuffix, string, isFuture) :
    output.replace(/%d/i, number);

}

function pastFuture (diff, output) {

var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
return isFunction(format) ? format(output) : format.replace(/%s/i, output);

}

var aliases = {};

function addUnitAlias (unit, shorthand) {

var lowerCase = unit.toLowerCase();
aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;

}

function normalizeUnits(units) {

return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;

}

function normalizeObjectUnits(inputObject) {

var normalizedInput = {},
    normalizedProp,
    prop;

for (prop in inputObject) {
    if (hasOwnProp(inputObject, prop)) {
        normalizedProp = normalizeUnits(prop);
        if (normalizedProp) {
            normalizedInput[normalizedProp] = inputObject[prop];
        }
    }
}

return normalizedInput;

}

var priorities = {};

function addUnitPriority(unit, priority) {

priorities[unit] = priority;

}

function getPrioritizedUnits(unitsObj) {

var units = [];
for (var u in unitsObj) {
    units.push({unit: u, priority: priorities[u]});
}
units.sort(function (a, b) {
    return a.priority - b.priority;
});
return units;

}

function makeGetSet (unit, keepTime) {

return function (value) {
    if (value != null) {
        set$1(this, unit, value);
        hooks.updateOffset(this, keepTime);
        return this;
    } else {
        return get(this, unit);
    }
};

}

function get (mom, unit) {

return mom.isValid() ?
    mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;

}

function set$1 (mom, unit, value) {

if (mom.isValid()) {
    mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
}

}

// MOMENTS

function stringGet (units) {

units = normalizeUnits(units);
if (isFunction(this[units])) {
    return this[units]();
}
return this;

}

function stringSet (units, value) {

if (typeof units === 'object') {
    units = normalizeObjectUnits(units);
    var prioritized = getPrioritizedUnits(units);
    for (var i = 0; i < prioritized.length; i++) {
        this[prioritized[i].unit](units[prioritized[i].unit]);
    }
} else {
    units = normalizeUnits(units);
    if (isFunction(this[units])) {
        return this[units](value);
    }
}
return this;

}

function zeroFill(number, targetLength, forceSign) {

var absNumber = '' + Math.abs(number),
    zerosToFill = targetLength - absNumber.length,
    sign = number >= 0;
return (sign ? (forceSign ? '+' : '') : '-') +
    Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;

}

var formattingTokens = /([[^[]*])|(\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w?|W?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;

var localFormattingTokens = /([[^[]*])|(\)?(LTS|LT|LL?L?L?|l{1,4})/g;

var formatFunctions = {};

var formatTokenFunctions = {};

// token: 'M' // padded: ['MM', 2] // ordinal: 'Mo' // callback: function () { this.month() + 1 } function addFormatToken (token, padded, ordinal, callback) {

var func = callback;
if (typeof callback === 'string') {
    func = function () {
        return this[callback]();
    };
}
if (token) {
    formatTokenFunctions[token] = func;
}
if (padded) {
    formatTokenFunctions[padded[0]] = function () {
        return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
    };
}
if (ordinal) {
    formatTokenFunctions[ordinal] = function () {
        return this.localeData().ordinal(func.apply(this, arguments), token);
    };
}

}

function removeFormattingTokens(input) {

if (input.match(/\[[\s\S]/)) {
    return input.replace(/^\[|\]$/g, '');
}
return input.replace(/\\/g, '');

}

function makeFormatFunction(format) {

var array = format.match(formattingTokens), i, length;

for (i = 0, length = array.length; i < length; i++) {
    if (formatTokenFunctions[array[i]]) {
        array[i] = formatTokenFunctions[array[i]];
    } else {
        array[i] = removeFormattingTokens(array[i]);
    }
}

return function (mom) {
    var output = '', i;
    for (i = 0; i < length; i++) {
        output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];
    }
    return output;
};

}

// format date using native date object function formatMoment(m, format) {

if (!m.isValid()) {
    return m.localeData().invalidDate();
}

format = expandFormat(format, m.localeData());
formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);

return formatFunctions[format](m);

}

function expandFormat(format, locale) {

var i = 5;

function replaceLongDateFormatTokens(input) {
    return locale.longDateFormat(input) || input;
}

localFormattingTokens.lastIndex = 0;
while (i >= 0 && localFormattingTokens.test(format)) {
    format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
    localFormattingTokens.lastIndex = 0;
    i -= 1;
}

return format;

}

var match1 = /d/; // 0 - 9 var match2 = /dd/; // 00 - 99 var match3 = /d{3}/; // 000 - 999 var match4 = /d{4}/; // 0000 - 9999 var match6 = /[+-]?d{6}/; // -999999 - 999999 var match1to2 = /dd?/; // 0 - 99 var match3to4 = /dddd?/; // 999 - 9999 var match5to6 = /dddddd?/; // 99999 - 999999 var match1to3 = /d{1,3}/; // 0 - 999 var match1to4 = /d{1,4}/; // 0 - 9999 var match1to6 = /[+-]?d{1,6}/; // -999999 - 999999

var matchUnsigned = /d+/; // 0 - inf var matchSigned = /[+-]?d+/; // -inf - inf

var matchOffset = /Z|dd:?dd/gi; // +00:00 -00:00 +0000 -0000 or Z var matchShortOffset = /Z|dd(?::?dd)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z

var matchTimestamp = /[+-]?d+(.d{1,3})?/; // 123456789 123456789.123

// any word (or two) characters or numbers including two/three word month in arabic. // includes scottish gaelic two word and hyphenated months var matchWord = /[0-9]*+|[u0600-u06FF/]+(s*?+){1,2}/i;

var regexes = {};

function addRegexToken (token, regex, strictRegex) {

regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
    return (isStrict && strictRegex) ? strictRegex : regex;
};

}

function getParseRegexForToken (token, config) {

if (!hasOwnProp(regexes, token)) {
    return new RegExp(unescapeFormat(token));
}

return regexes[token](config._strict, config._locale);

}

// Code from stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript function unescapeFormat(s) {

return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
    return p1 || p2 || p3 || p4;
}));

}

function regexEscape(s) {

return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');

}

var tokens = {};

function addParseToken (token, callback) {

var i, func = callback;
if (typeof token === 'string') {
    token = [token];
}
if (isNumber(callback)) {
    func = function (input, array) {
        array[callback] = toInt(input);
    };
}
for (i = 0; i < token.length; i++) {
    tokens[token[i]] = func;
}

}

function addWeekParseToken (token, callback) {

addParseToken(token, function (input, array, config, token) {
    config._w = config._w || {};
    callback(input, config._w, config, token);
});

}

function addTimeToArrayFromToken(token, input, config) {

if (input != null && hasOwnProp(tokens, token)) {
    tokens[token](input, config._a, config, token);
}

}

var YEAR = 0; var MONTH = 1; var DATE = 2; var HOUR = 3; var MINUTE = 4; var SECOND = 5; var MILLISECOND = 6; var WEEK = 7; var WEEKDAY = 8;

var indexOf;

if (Array.prototype.indexOf) {

indexOf = Array.prototype.indexOf;

} else {

indexOf = function (o) {
    // I know
    var i;
    for (i = 0; i < this.length; ++i) {
        if (this[i] === o) {
            return i;
        }
    }
    return -1;
};

}

var indexOf$1 = indexOf;

function daysInMonth(year, month) {

return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();

}

// FORMATTING

addFormatToken('M', ['MM', 2], 'Mo', function () {

return this.month() + 1;

});

addFormatToken('MMM', 0, 0, function (format) {

return this.localeData().monthsShort(this, format);

});

addFormatToken('MMMM', 0, 0, function (format) {

return this.localeData().months(this, format);

});

// ALIASES

addUnitAlias('month', 'M');

// PRIORITY

addUnitPriority('month', 8);

// PARSING

addRegexToken('M', match1to2); addRegexToken('MM', match1to2, match2); addRegexToken('MMM', function (isStrict, locale) {

return locale.monthsShortRegex(isStrict);

}); addRegexToken('MMMM', function (isStrict, locale) {

return locale.monthsRegex(isStrict);

});

addParseToken(['M', 'MM'], function (input, array) {

array[MONTH] = toInt(input) - 1;

});

addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {

var month = config._locale.monthsParse(input, token, config._strict);
// if we didn't find a month name, mark the date as invalid.
if (month != null) {
    array[MONTH] = month;
} else {
    getParsingFlags(config).invalidMonth = input;
}

});

// LOCALES

var MONTHS_IN_FORMAT = /D?([[^[]]*]|s)+MMMM?/; var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'); function localeMonths (m, format) {

if (!m) {
    return isArray(this._months) ? this._months :
        this._months['standalone'];
}
return isArray(this._months) ? this._months[m.month()] :
    this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];

}

var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'); function localeMonthsShort (m, format) {

if (!m) {
    return isArray(this._monthsShort) ? this._monthsShort :
        this._monthsShort['standalone'];
}
return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
    this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];

}

function handleStrictParse(monthName, format, strict) {

var i, ii, mom, llc = monthName.toLocaleLowerCase();
if (!this._monthsParse) {
    // this is not used
    this._monthsParse = [];
    this._longMonthsParse = [];
    this._shortMonthsParse = [];
    for (i = 0; i < 12; ++i) {
        mom = createUTC([2000, i]);
        this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
        this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
    }
}

if (strict) {
    if (format === 'MMM') {
        ii = indexOf$1.call(this._shortMonthsParse, llc);
        return ii !== -1 ? ii : null;
    } else {
        ii = indexOf$1.call(this._longMonthsParse, llc);
        return ii !== -1 ? ii : null;
    }
} else {
    if (format === 'MMM') {
        ii = indexOf$1.call(this._shortMonthsParse, llc);
        if (ii !== -1) {
            return ii;
        }
        ii = indexOf$1.call(this._longMonthsParse, llc);
        return ii !== -1 ? ii : null;
    } else {
        ii = indexOf$1.call(this._longMonthsParse, llc);
        if (ii !== -1) {
            return ii;
        }
        ii = indexOf$1.call(this._shortMonthsParse, llc);
        return ii !== -1 ? ii : null;
    }
}

}

function localeMonthsParse (monthName, format, strict) {

var i, mom, regex;

if (this._monthsParseExact) {
    return handleStrictParse.call(this, monthName, format, strict);
}

if (!this._monthsParse) {
    this._monthsParse = [];
    this._longMonthsParse = [];
    this._shortMonthsParse = [];
}

// TODO: add sorting
// Sorting makes sure if one month (or abbr) is a prefix of another
// see sorting in computeMonthsParse
for (i = 0; i < 12; i++) {
    // make the regex if we don't have it already
    mom = createUTC([2000, i]);
    if (strict && !this._longMonthsParse[i]) {
        this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
        this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
    }
    if (!strict && !this._monthsParse[i]) {
        regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
        this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
    }
    // test the regex
    if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
        return i;
    } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
        return i;
    } else if (!strict && this._monthsParse[i].test(monthName)) {
        return i;
    }
}

}

// MOMENTS

function setMonth (mom, value) {

var dayOfMonth;

if (!mom.isValid()) {
    // No op
    return mom;
}

if (typeof value === 'string') {
    if (/^\d+$/.test(value)) {
        value = toInt(value);
    } else {
        value = mom.localeData().monthsParse(value);
        // TODO: Another silent failure?
        if (!isNumber(value)) {
            return mom;
        }
    }
}

dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
return mom;

}

function getSetMonth (value) {

if (value != null) {
    setMonth(this, value);
    hooks.updateOffset(this, true);
    return this;
} else {
    return get(this, 'Month');
}

}

function getDaysInMonth () {

return daysInMonth(this.year(), this.month());

}

var defaultMonthsShortRegex = matchWord; function monthsShortRegex (isStrict) {

if (this._monthsParseExact) {
    if (!hasOwnProp(this, '_monthsRegex')) {
        computeMonthsParse.call(this);
    }
    if (isStrict) {
        return this._monthsShortStrictRegex;
    } else {
        return this._monthsShortRegex;
    }
} else {
    if (!hasOwnProp(this, '_monthsShortRegex')) {
        this._monthsShortRegex = defaultMonthsShortRegex;
    }
    return this._monthsShortStrictRegex && isStrict ?
        this._monthsShortStrictRegex : this._monthsShortRegex;
}

}

var defaultMonthsRegex = matchWord; function monthsRegex (isStrict) {

if (this._monthsParseExact) {
    if (!hasOwnProp(this, '_monthsRegex')) {
        computeMonthsParse.call(this);
    }
    if (isStrict) {
        return this._monthsStrictRegex;
    } else {
        return this._monthsRegex;
    }
} else {
    if (!hasOwnProp(this, '_monthsRegex')) {
        this._monthsRegex = defaultMonthsRegex;
    }
    return this._monthsStrictRegex && isStrict ?
        this._monthsStrictRegex : this._monthsRegex;
}

}

function computeMonthsParse () {

function cmpLenRev(a, b) {
    return b.length - a.length;
}

var shortPieces = [], longPieces = [], mixedPieces = [],
    i, mom;
for (i = 0; i < 12; i++) {
    // make the regex if we don't have it already
    mom = createUTC([2000, i]);
    shortPieces.push(this.monthsShort(mom, ''));
    longPieces.push(this.months(mom, ''));
    mixedPieces.push(this.months(mom, ''));
    mixedPieces.push(this.monthsShort(mom, ''));
}
// Sorting makes sure if one month (or abbr) is a prefix of another it
// will match the longer piece.
shortPieces.sort(cmpLenRev);
longPieces.sort(cmpLenRev);
mixedPieces.sort(cmpLenRev);
for (i = 0; i < 12; i++) {
    shortPieces[i] = regexEscape(shortPieces[i]);
    longPieces[i] = regexEscape(longPieces[i]);
}
for (i = 0; i < 24; i++) {
    mixedPieces[i] = regexEscape(mixedPieces[i]);
}

this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
this._monthsShortRegex = this._monthsRegex;
this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');

}

// FORMATTING

addFormatToken('Y', 0, 0, function () {

var y = this.year();
return y <= 9999 ? '' + y : '+' + y;

});

addFormatToken(0, ['YY', 2], 0, function () {

return this.year() % 100;

});

addFormatToken(0, ['YYYY', 4], 0, 'year'); addFormatToken(0, ['YYYYY', 5], 0, 'year'); addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');

// ALIASES

addUnitAlias('year', 'y');

// PRIORITIES

addUnitPriority('year', 1);

// PARSING

addRegexToken('Y', matchSigned); addRegexToken('YY', match1to2, match2); addRegexToken('YYYY', match1to4, match4); addRegexToken('YYYYY', match1to6, match6); addRegexToken('YYYYYY', match1to6, match6);

addParseToken(['YYYYY', 'YYYYYY'], YEAR); addParseToken('YYYY', function (input, array) {

array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);

}); addParseToken('YY', function (input, array) {

array[YEAR] = hooks.parseTwoDigitYear(input);

}); addParseToken('Y', function (input, array) {

array[YEAR] = parseInt(input, 10);

});

// HELPERS

function daysInYear(year) {

return isLeapYear(year) ? 366 : 365;

}

function isLeapYear(year) {

return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;

}

// HOOKS

hooks.parseTwoDigitYear = function (input) {

return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);

};

// MOMENTS

var getSetYear = makeGetSet('FullYear', true);

function getIsLeapYear () {

return isLeapYear(this.year());

}

function createDate (y, m, d, h, M, s, ms) {

// can't just apply() to create a date:
// https://stackoverflow.com/q/181348
var date = new Date(y, m, d, h, M, s, ms);

// the date constructor remaps years 0-99 to 1900-1999
if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
    date.setFullYear(y);
}
return date;

}

function createUTCDate (y) {

var date = new Date(Date.UTC.apply(null, arguments));

// the Date.UTC function remaps years 0-99 to 1900-1999
if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
    date.setUTCFullYear(y);
}
return date;

}

// start-of-first-week - start-of-year function firstWeekOffset(year, dow, doy) {

var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
    fwd = 7 + dow - doy,
    // first-week day local weekday -- which local weekday is fwd
    fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;

return -fwdlw + fwd - 1;

}

// en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday function dayOfYearFromWeeks(year, week, weekday, dow, doy) {

var localWeekday = (7 + weekday - dow) % 7,
    weekOffset = firstWeekOffset(year, dow, doy),
    dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
    resYear, resDayOfYear;

if (dayOfYear <= 0) {
    resYear = year - 1;
    resDayOfYear = daysInYear(resYear) + dayOfYear;
} else if (dayOfYear > daysInYear(year)) {
    resYear = year + 1;
    resDayOfYear = dayOfYear - daysInYear(year);
} else {
    resYear = year;
    resDayOfYear = dayOfYear;
}

return {
    year: resYear,
    dayOfYear: resDayOfYear
};

}

function weekOfYear(mom, dow, doy) {

var weekOffset = firstWeekOffset(mom.year(), dow, doy),
    week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
    resWeek, resYear;

if (week < 1) {
    resYear = mom.year() - 1;
    resWeek = week + weeksInYear(resYear, dow, doy);
} else if (week > weeksInYear(mom.year(), dow, doy)) {
    resWeek = week - weeksInYear(mom.year(), dow, doy);
    resYear = mom.year() + 1;
} else {
    resYear = mom.year();
    resWeek = week;
}

return {
    week: resWeek,
    year: resYear
};

}

function weeksInYear(year, dow, doy) {

var weekOffset = firstWeekOffset(year, dow, doy),
    weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;

}

// FORMATTING

addFormatToken('w', ['ww', 2], 'wo', 'week'); addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');

// ALIASES

addUnitAlias('week', 'w'); addUnitAlias('isoWeek', 'W');

// PRIORITIES

addUnitPriority('week', 5); addUnitPriority('isoWeek', 5);

// PARSING

addRegexToken('w', match1to2); addRegexToken('ww', match1to2, match2); addRegexToken('W', match1to2); addRegexToken('WW', match1to2, match2);

addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {

week[token.substr(0, 1)] = toInt(input);

});

// HELPERS

// LOCALES

function localeWeek (mom) {

return weekOfYear(mom, this._week.dow, this._week.doy).week;

}

var defaultLocaleWeek = {

dow : 0, // Sunday is the first day of the week.
doy : 6  // The week that contains Jan 1st is the first week of the year.

};

function localeFirstDayOfWeek () {

return this._week.dow;

}

function localeFirstDayOfYear () {

return this._week.doy;

}

// MOMENTS

function getSetWeek (input) {

var week = this.localeData().week(this);
return input == null ? week : this.add((input - week) * 7, 'd');

}

function getSetISOWeek (input) {

var week = weekOfYear(this, 1, 4).week;
return input == null ? week : this.add((input - week) * 7, 'd');

}

// FORMATTING

addFormatToken('d', 0, 'do', 'day');

addFormatToken('dd', 0, 0, function (format) {

return this.localeData().weekdaysMin(this, format);

});

addFormatToken('ddd', 0, 0, function (format) {

return this.localeData().weekdaysShort(this, format);

});

addFormatToken('dddd', 0, 0, function (format) {

return this.localeData().weekdays(this, format);

});

addFormatToken('e', 0, 0, 'weekday'); addFormatToken('E', 0, 0, 'isoWeekday');

// ALIASES

addUnitAlias('day', 'd'); addUnitAlias('weekday', 'e'); addUnitAlias('isoWeekday', 'E');

// PRIORITY addUnitPriority('day', 11); addUnitPriority('weekday', 11); addUnitPriority('isoWeekday', 11);

// PARSING

addRegexToken('d', match1to2); addRegexToken('e', match1to2); addRegexToken('E', match1to2); addRegexToken('dd', function (isStrict, locale) {

return locale.weekdaysMinRegex(isStrict);

}); addRegexToken('ddd', function (isStrict, locale) {

return locale.weekdaysShortRegex(isStrict);

}); addRegexToken('dddd', function (isStrict, locale) {

return locale.weekdaysRegex(isStrict);

});

addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {

var weekday = config._locale.weekdaysParse(input, token, config._strict);
// if we didn't get a weekday name, mark the date as invalid
if (weekday != null) {
    week.d = weekday;
} else {
    getParsingFlags(config).invalidWeekday = input;
}

});

addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {

week[token] = toInt(input);

});

// HELPERS

function parseWeekday(input, locale) {

if (typeof input !== 'string') {
    return input;
}

if (!isNaN(input)) {
    return parseInt(input, 10);
}

input = locale.weekdaysParse(input);
if (typeof input === 'number') {
    return input;
}

return null;

}

function parseIsoWeekday(input, locale) {

if (typeof input === 'string') {
    return locale.weekdaysParse(input) % 7 || 7;
}
return isNaN(input) ? null : input;

}

// LOCALES

var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'); function localeWeekdays (m, format) {

if (!m) {
    return isArray(this._weekdays) ? this._weekdays :
        this._weekdays['standalone'];
}
return isArray(this._weekdays) ? this._weekdays[m.day()] :
    this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];

}

var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'); function localeWeekdaysShort (m) {

return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;

}

var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'); function localeWeekdaysMin (m) {

return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;

}

function handleStrictParse$1(weekdayName, format, strict) {

var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
if (!this._weekdaysParse) {
    this._weekdaysParse = [];
    this._shortWeekdaysParse = [];
    this._minWeekdaysParse = [];

    for (i = 0; i < 7; ++i) {
        mom = createUTC([2000, 1]).day(i);
        this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
        this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
        this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
    }
}

if (strict) {
    if (format === 'dddd') {
        ii = indexOf$1.call(this._weekdaysParse, llc);
        return ii !== -1 ? ii : null;
    } else if (format === 'ddd') {
        ii = indexOf$1.call(this._shortWeekdaysParse, llc);
        return ii !== -1 ? ii : null;
    } else {
        ii = indexOf$1.call(this._minWeekdaysParse, llc);
        return ii !== -1 ? ii : null;
    }
} else {
    if (format === 'dddd') {
        ii = indexOf$1.call(this._weekdaysParse, llc);
        if (ii !== -1) {
            return ii;
        }
        ii = indexOf$1.call(this._shortWeekdaysParse, llc);
        if (ii !== -1) {
            return ii;
        }
        ii = indexOf$1.call(this._minWeekdaysParse, llc);
        return ii !== -1 ? ii : null;
    } else if (format === 'ddd') {
        ii = indexOf$1.call(this._shortWeekdaysParse, llc);
        if (ii !== -1) {
            return ii;
        }
        ii = indexOf$1.call(this._weekdaysParse, llc);
        if (ii !== -1) {
            return ii;
        }
        ii = indexOf$1.call(this._minWeekdaysParse, llc);
        return ii !== -1 ? ii : null;
    } else {
        ii = indexOf$1.call(this._minWeekdaysParse, llc);
        if (ii !== -1) {
            return ii;
        }
        ii = indexOf$1.call(this._weekdaysParse, llc);
        if (ii !== -1) {
            return ii;
        }
        ii = indexOf$1.call(this._shortWeekdaysParse, llc);
        return ii !== -1 ? ii : null;
    }
}

}

function localeWeekdaysParse (weekdayName, format, strict) {

var i, mom, regex;

if (this._weekdaysParseExact) {
    return handleStrictParse$1.call(this, weekdayName, format, strict);
}

if (!this._weekdaysParse) {
    this._weekdaysParse = [];
    this._minWeekdaysParse = [];
    this._shortWeekdaysParse = [];
    this._fullWeekdaysParse = [];
}

for (i = 0; i < 7; i++) {
    // make the regex if we don't have it already

    mom = createUTC([2000, 1]).day(i);
    if (strict && !this._fullWeekdaysParse[i]) {
        this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\.?') + '$', 'i');
        this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\.?') + '$', 'i');
        this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\.?') + '$', 'i');
    }
    if (!this._weekdaysParse[i]) {
        regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
        this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
    }
    // test the regex
    if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
        return i;
    } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
        return i;
    } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
        return i;
    } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
        return i;
    }
}

}

// MOMENTS

function getSetDayOfWeek (input) {

if (!this.isValid()) {
    return input != null ? this : NaN;
}
var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
if (input != null) {
    input = parseWeekday(input, this.localeData());
    return this.add(input - day, 'd');
} else {
    return day;
}

}

function getSetLocaleDayOfWeek (input) {

if (!this.isValid()) {
    return input != null ? this : NaN;
}
var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
return input == null ? weekday : this.add(input - weekday, 'd');

}

function getSetISODayOfWeek (input) {

if (!this.isValid()) {
    return input != null ? this : NaN;
}

// behaves the same as moment#day except
// as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
// as a setter, sunday should belong to the previous week.

if (input != null) {
    var weekday = parseIsoWeekday(input, this.localeData());
    return this.day(this.day() % 7 ? weekday : weekday - 7);
} else {
    return this.day() || 7;
}

}

var defaultWeekdaysRegex = matchWord; function weekdaysRegex (isStrict) {

if (this._weekdaysParseExact) {
    if (!hasOwnProp(this, '_weekdaysRegex')) {
        computeWeekdaysParse.call(this);
    }
    if (isStrict) {
        return this._weekdaysStrictRegex;
    } else {
        return this._weekdaysRegex;
    }
} else {
    if (!hasOwnProp(this, '_weekdaysRegex')) {
        this._weekdaysRegex = defaultWeekdaysRegex;
    }
    return this._weekdaysStrictRegex && isStrict ?
        this._weekdaysStrictRegex : this._weekdaysRegex;
}

}

var defaultWeekdaysShortRegex = matchWord; function weekdaysShortRegex (isStrict) {

if (this._weekdaysParseExact) {
    if (!hasOwnProp(this, '_weekdaysRegex')) {
        computeWeekdaysParse.call(this);
    }
    if (isStrict) {
        return this._weekdaysShortStrictRegex;
    } else {
        return this._weekdaysShortRegex;
    }
} else {
    if (!hasOwnProp(this, '_weekdaysShortRegex')) {
        this._weekdaysShortRegex = defaultWeekdaysShortRegex;
    }
    return this._weekdaysShortStrictRegex && isStrict ?
        this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
}

}

var defaultWeekdaysMinRegex = matchWord; function weekdaysMinRegex (isStrict) {

if (this._weekdaysParseExact) {
    if (!hasOwnProp(this, '_weekdaysRegex')) {
        computeWeekdaysParse.call(this);
    }
    if (isStrict) {
        return this._weekdaysMinStrictRegex;
    } else {
        return this._weekdaysMinRegex;
    }
} else {
    if (!hasOwnProp(this, '_weekdaysMinRegex')) {
        this._weekdaysMinRegex = defaultWeekdaysMinRegex;
    }
    return this._weekdaysMinStrictRegex && isStrict ?
        this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
}

}

function computeWeekdaysParse () {

function cmpLenRev(a, b) {
    return b.length - a.length;
}

var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],
    i, mom, minp, shortp, longp;
for (i = 0; i < 7; i++) {
    // make the regex if we don't have it already
    mom = createUTC([2000, 1]).day(i);
    minp = this.weekdaysMin(mom, '');
    shortp = this.weekdaysShort(mom, '');
    longp = this.weekdays(mom, '');
    minPieces.push(minp);
    shortPieces.push(shortp);
    longPieces.push(longp);
    mixedPieces.push(minp);
    mixedPieces.push(shortp);
    mixedPieces.push(longp);
}
// Sorting makes sure if one weekday (or abbr) is a prefix of another it
// will match the longer piece.
minPieces.sort(cmpLenRev);
shortPieces.sort(cmpLenRev);
longPieces.sort(cmpLenRev);
mixedPieces.sort(cmpLenRev);
for (i = 0; i < 7; i++) {
    shortPieces[i] = regexEscape(shortPieces[i]);
    longPieces[i] = regexEscape(longPieces[i]);
    mixedPieces[i] = regexEscape(mixedPieces[i]);
}

this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
this._weekdaysShortRegex = this._weekdaysRegex;
this._weekdaysMinRegex = this._weekdaysRegex;

this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');

}

// FORMATTING

function hFormat() {

return this.hours() % 12 || 12;

}

function kFormat() {

return this.hours() || 24;

}

addFormatToken('H', ['HH', 2], 0, 'hour'); addFormatToken('h', ['hh', 2], 0, hFormat); addFormatToken('k', ['kk', 2], 0, kFormat);

addFormatToken('hmm', 0, 0, function () {

return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);

});

addFormatToken('hmmss', 0, 0, function () {

return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
    zeroFill(this.seconds(), 2);

});

addFormatToken('Hmm', 0, 0, function () {

return '' + this.hours() + zeroFill(this.minutes(), 2);

});

addFormatToken('Hmmss', 0, 0, function () {

return '' + this.hours() + zeroFill(this.minutes(), 2) +
    zeroFill(this.seconds(), 2);

});

function meridiem (token, lowercase) {

addFormatToken(token, 0, 0, function () {
    return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
});

}

meridiem('a', true); meridiem('A', false);

// ALIASES

addUnitAlias('hour', 'h');

// PRIORITY addUnitPriority('hour', 13);

// PARSING

function matchMeridiem (isStrict, locale) {

return locale._meridiemParse;

}

addRegexToken('a', matchMeridiem); addRegexToken('A', matchMeridiem); addRegexToken('H', match1to2); addRegexToken('h', match1to2); addRegexToken('k', match1to2); addRegexToken('HH', match1to2, match2); addRegexToken('hh', match1to2, match2); addRegexToken('kk', match1to2, match2);

addRegexToken('hmm', match3to4); addRegexToken('hmmss', match5to6); addRegexToken('Hmm', match3to4); addRegexToken('Hmmss', match5to6);

addParseToken(['H', 'HH'], HOUR); addParseToken(['k', 'kk'], function (input, array, config) {

var kInput = toInt(input);
array[HOUR] = kInput === 24 ? 0 : kInput;

}); addParseToken(['a', 'A'], function (input, array, config) {

config._isPm = config._locale.isPM(input);
config._meridiem = input;

}); addParseToken(['h', 'hh'], function (input, array, config) {

array[HOUR] = toInt(input);
getParsingFlags(config).bigHour = true;

}); addParseToken('hmm', function (input, array, config) {

var pos = input.length - 2;
array[HOUR] = toInt(input.substr(0, pos));
array[MINUTE] = toInt(input.substr(pos));
getParsingFlags(config).bigHour = true;

}); addParseToken('hmmss', function (input, array, config) {

var pos1 = input.length - 4;
var pos2 = input.length - 2;
array[HOUR] = toInt(input.substr(0, pos1));
array[MINUTE] = toInt(input.substr(pos1, 2));
array[SECOND] = toInt(input.substr(pos2));
getParsingFlags(config).bigHour = true;

}); addParseToken('Hmm', function (input, array, config) {

var pos = input.length - 2;
array[HOUR] = toInt(input.substr(0, pos));
array[MINUTE] = toInt(input.substr(pos));

}); addParseToken('Hmmss', function (input, array, config) {

var pos1 = input.length - 4;
var pos2 = input.length - 2;
array[HOUR] = toInt(input.substr(0, pos1));
array[MINUTE] = toInt(input.substr(pos1, 2));
array[SECOND] = toInt(input.substr(pos2));

});

// LOCALES

function localeIsPM (input) {

// IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
// Using charAt should be more compatible.
return ((input + '').toLowerCase().charAt(0) === 'p');

}

var defaultLocaleMeridiemParse = /[ap].?m?.?/i; function localeMeridiem (hours, minutes, isLower) {

if (hours > 11) {
    return isLower ? 'pm' : 'PM';
} else {
    return isLower ? 'am' : 'AM';
}

}

// MOMENTS

// Setting the hour should keep the time, because the user explicitly // specified which hour he wants. So trying to maintain the same hour (in // a new timezone) makes sense. Adding/subtracting hours does not follow // this rule. var getSetHour = makeGetSet('Hours', true);

// months // week // weekdays // meridiem var baseConfig = {

calendar: defaultCalendar,
longDateFormat: defaultLongDateFormat,
invalidDate: defaultInvalidDate,
ordinal: defaultOrdinal,
dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
relativeTime: defaultRelativeTime,

months: defaultLocaleMonths,
monthsShort: defaultLocaleMonthsShort,

week: defaultLocaleWeek,

weekdays: defaultLocaleWeekdays,
weekdaysMin: defaultLocaleWeekdaysMin,
weekdaysShort: defaultLocaleWeekdaysShort,

meridiemParse: defaultLocaleMeridiemParse

};

// internal storage for locale config files var locales = {}; var localeFamilies = {}; var globalLocale;

function normalizeLocale(key) {

return key ? key.toLowerCase().replace('_', '-') : key;

}

// pick the locale from the array // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root function chooseLocale(names) {

var i = 0, j, next, locale, split;

while (i < names.length) {
    split = normalizeLocale(names[i]).split('-');
    j = split.length;
    next = normalizeLocale(names[i + 1]);
    next = next ? next.split('-') : null;
    while (j > 0) {
        locale = loadLocale(split.slice(0, j).join('-'));
        if (locale) {
            return locale;
        }
        if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
            //the next array item is better than a shallower substring of this one
            break;
        }
        j--;
    }
    i++;
}
return null;

}

function loadLocale(name) {

var oldLocale = null;
// TODO: Find a better way to register and load all the locales in Node
if (!locales[name] && (typeof module !== 'undefined') &&
        module && module.exports) {
    try {
        oldLocale = globalLocale._abbr;
        __webpack_require__(202)("./" + name);
        // because defineLocale currently also sets the global locale, we
        // want to undo that for lazy loaded locales
        getSetGlobalLocale(oldLocale);
    } catch (e) { }
}
return locales[name];

}

// This function will load locale and then set the global locale. If // no arguments are passed in, it will simply return the current global // locale key. function getSetGlobalLocale (key, values) {

var data;
if (key) {
    if (isUndefined(values)) {
        data = getLocale(key);
    }
    else {
        data = defineLocale(key, values);
    }

    if (data) {
        // moment.duration._locale = moment._locale = data;
        globalLocale = data;
    }
}

return globalLocale._abbr;

}

function defineLocale (name, config) {

if (config !== null) {
    var parentConfig = baseConfig;
    config.abbr = name;
    if (locales[name] != null) {
        deprecateSimple('defineLocaleOverride',
                'use moment.updateLocale(localeName, config) to change ' +
                'an existing locale. moment.defineLocale(localeName, ' +
                'config) should only be used for creating a new locale ' +
                'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
        parentConfig = locales[name]._config;
    } else if (config.parentLocale != null) {
        if (locales[config.parentLocale] != null) {
            parentConfig = locales[config.parentLocale]._config;
        } else {
            if (!localeFamilies[config.parentLocale]) {
                localeFamilies[config.parentLocale] = [];
            }
            localeFamilies[config.parentLocale].push({
                name: name,
                config: config
            });
            return null;
        }
    }
    locales[name] = new Locale(mergeConfigs(parentConfig, config));

    if (localeFamilies[name]) {
        localeFamilies[name].forEach(function (x) {
            defineLocale(x.name, x.config);
        });
    }

    // backwards compat for now: also set the locale
    // make sure we set the locale AFTER all child locales have been
    // created, so we won't end up with the child locale set.
    getSetGlobalLocale(name);

    return locales[name];
} else {
    // useful for testing
    delete locales[name];
    return null;
}

}

function updateLocale(name, config) {

if (config != null) {
    var locale, parentConfig = baseConfig;
    // MERGE
    if (locales[name] != null) {
        parentConfig = locales[name]._config;
    }
    config = mergeConfigs(parentConfig, config);
    locale = new Locale(config);
    locale.parentLocale = locales[name];
    locales[name] = locale;

    // backwards compat for now: also set the locale
    getSetGlobalLocale(name);
} else {
    // pass null for config to unupdate, useful for tests
    if (locales[name] != null) {
        if (locales[name].parentLocale != null) {
            locales[name] = locales[name].parentLocale;
        } else if (locales[name] != null) {
            delete locales[name];
        }
    }
}
return locales[name];

}

// returns locale data function getLocale (key) {

var locale;

if (key && key._locale && key._locale._abbr) {
    key = key._locale._abbr;
}

if (!key) {
    return globalLocale;
}

if (!isArray(key)) {
    //short-circuit everything else
    locale = loadLocale(key);
    if (locale) {
        return locale;
    }
    key = [key];
}

return chooseLocale(key);

}

function listLocales() {

return keys$1(locales);

}

function checkOverflow (m) {

var overflow;
var a = m._a;

if (a && getParsingFlags(m).overflow === -2) {
    overflow =
        a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
        a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
        a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
        a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
        a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
        a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
        -1;

    if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
        overflow = DATE;
    }
    if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
        overflow = WEEK;
    }
    if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
        overflow = WEEKDAY;
    }

    getParsingFlags(m).overflow = overflow;
}

return m;

}

// iso 8601 regex // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00) var extendedIsoRegex = /^s*((?:d{6}|d{4})-(?:dd-dd|Wdd-d|Wdd|ddd|dd))(?:(T| )(dd(?::dd(?::dd(?:[.,]d+)?)?)?)(dd(?::?dd)?|s*Z)?)?$/; var basicIsoRegex = /^s*((?:d{6}|d{4})(?:dddd|Wddd|Wdd|ddd|dd))(?:(T| )(dd(?:dd(?:dd(?:[.,]d+)?)?)?)(dd(?::?dd)?|s*Z)?)?$/;

var tzRegex = /Z|dd(?::?dd)?/;

var isoDates = [

['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
['GGGG-[W]WW', /\d{4}-W\d\d/, false],
['YYYY-DDD', /\d{4}-\d{3}/],
['YYYY-MM', /\d{4}-\d\d/, false],
['YYYYYYMMDD', /[+-]\d{10}/],
['YYYYMMDD', /\d{8}/],
// YYYYMM is NOT allowed by the standard
['GGGG[W]WWE', /\d{4}W\d{3}/],
['GGGG[W]WW', /\d{4}W\d{2}/, false],
['YYYYDDD', /\d{7}/]

];

// iso time formats and regexes var isoTimes = [

['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
['HH:mm:ss', /\d\d:\d\d:\d\d/],
['HH:mm', /\d\d:\d\d/],
['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
['HHmmss', /\d\d\d\d\d\d/],
['HHmm', /\d\d\d\d/],
['HH', /\d\d/]

];

var aspNetJsonRegex = /^/?Date((-?d+)/i;

// date from iso format function configFromISO(config) {

var i, l,
    string = config._i,
    match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
    allowTime, dateFormat, timeFormat, tzFormat;

if (match) {
    getParsingFlags(config).iso = true;

    for (i = 0, l = isoDates.length; i < l; i++) {
        if (isoDates[i][1].exec(match[1])) {
            dateFormat = isoDates[i][0];
            allowTime = isoDates[i][2] !== false;
            break;
        }
    }
    if (dateFormat == null) {
        config._isValid = false;
        return;
    }
    if (match[3]) {
        for (i = 0, l = isoTimes.length; i < l; i++) {
            if (isoTimes[i][1].exec(match[3])) {
                // match[2] should be 'T' or space
                timeFormat = (match[2] || ' ') + isoTimes[i][0];
                break;
            }
        }
        if (timeFormat == null) {
            config._isValid = false;
            return;
        }
    }
    if (!allowTime && timeFormat != null) {
        config._isValid = false;
        return;
    }
    if (match[4]) {
        if (tzRegex.exec(match[4])) {
            tzFormat = 'Z';
        } else {
            config._isValid = false;
            return;
        }
    }
    config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
    configFromStringAndFormat(config);
} else {
    config._isValid = false;
}

}

// RFC 2822 regex: For details see tools.ietf.org/html/rfc2822#section-3.3 var basicRfcRegex = /^((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),?s)?(d?ds(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)s(?:dd)?dds)(dd:dd)(:dd)?(s(?:UT|GMT|[SD]T||[+-]d{4}))$/;

// date and time from ref 2822 format function configFromRFC2822(config) {

var string, match, dayFormat,
    dateFormat, timeFormat, tzFormat;
var timezones = {
    ' GMT': ' +0000',
    ' EDT': ' -0400',
    ' EST': ' -0500',
    ' CDT': ' -0500',
    ' CST': ' -0600',
    ' MDT': ' -0600',
    ' MST': ' -0700',
    ' PDT': ' -0700',
    ' PST': ' -0800'
};
var military = 'YXWVUTSRQPONZABCDEFGHIKLM';
var timezone, timezoneIndex;

string = config._i
    .replace(/\([^\)]*\)|[\n\t]/g, ' ') // Remove comments and folding whitespace
    .replace(/(\s\s+)/g, ' ') // Replace multiple-spaces with a single space
    .replace(/^\s|\s$/g, ''); // Remove leading and trailing spaces
match = basicRfcRegex.exec(string);

if (match) {
    dayFormat = match[1] ? 'ddd' + ((match[1].length === 5) ? ', ' : ' ') : '';
    dateFormat = 'D MMM ' + ((match[2].length > 10) ? 'YYYY ' : 'YY ');
    timeFormat = 'HH:mm' + (match[4] ? ':ss' : '');

    // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.
    if (match[1]) { // day of week given
        var momentDate = new Date(match[2]);
        var momentDay = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'][momentDate.getDay()];

        if (match[1].substr(0,3) !== momentDay) {
            getParsingFlags(config).weekdayMismatch = true;
            config._isValid = false;
            return;
        }
    }

    switch (match[5].length) {
        case 2: // military
            if (timezoneIndex === 0) {
                timezone = ' +0000';
            } else {
                timezoneIndex = military.indexOf(match[5][1].toUpperCase()) - 12;
                timezone = ((timezoneIndex < 0) ? ' -' : ' +') +
                    (('' + timezoneIndex).replace(/^-?/, '0')).match(/..$/)[0] + '00';
            }
            break;
        case 4: // Zone
            timezone = timezones[match[5]];
            break;
        default: // UT or +/-9999
            timezone = timezones[' GMT'];
    }
    match[5] = timezone;
    config._i = match.splice(1).join('');
    tzFormat = ' ZZ';
    config._f = dayFormat + dateFormat + timeFormat + tzFormat;
    configFromStringAndFormat(config);
    getParsingFlags(config).rfc2822 = true;
} else {
    config._isValid = false;
}

}

// date from iso format or fallback function configFromString(config) {

var matched = aspNetJsonRegex.exec(config._i);

if (matched !== null) {
    config._d = new Date(+matched[1]);
    return;
}

configFromISO(config);
if (config._isValid === false) {
    delete config._isValid;
} else {
    return;
}

configFromRFC2822(config);
if (config._isValid === false) {
    delete config._isValid;
} else {
    return;
}

// Final attempt, use Input Fallback
hooks.createFromInputFallback(config);

}

hooks.createFromInputFallback = deprecate(

'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
'discouraged and will be removed in an upcoming major release. Please refer to ' +
'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
function (config) {
    config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
}

);

// Pick the first defined of two or three arguments. function defaults(a, b, c) {

if (a != null) {
    return a;
}
if (b != null) {
    return b;
}
return c;

}

function currentDateArray(config) {

// hooks is actually the exported moment object
var nowValue = new Date(hooks.now());
if (config._useUTC) {
    return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
}
return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];

}

// convert an array to a date. // the array should mirror the parameters below // note: all values past the year are optional and will default to the lowest possible value. // [year, month, day , hour, minute, second, millisecond] function configFromArray (config) {

var i, date, input = [], currentDate, yearToUse;

if (config._d) {
    return;
}

currentDate = currentDateArray(config);

//compute day of the year from weeks and weekdays
if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
    dayOfYearFromWeekInfo(config);
}

//if the day of the year is set, figure out what it is
if (config._dayOfYear != null) {
    yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);

    if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
        getParsingFlags(config)._overflowDayOfYear = true;
    }

    date = createUTCDate(yearToUse, 0, config._dayOfYear);
    config._a[MONTH] = date.getUTCMonth();
    config._a[DATE] = date.getUTCDate();
}

// Default to current date.
// * if no year, month, day of month are given, default to today
// * if day of month is given, default month and year
// * if month is given, default only year
// * if year is given, don't default anything
for (i = 0; i < 3 && config._a[i] == null; ++i) {
    config._a[i] = input[i] = currentDate[i];
}

// Zero out whatever was not defaulted, including time
for (; i < 7; i++) {
    config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
}

// Check for 24:00:00.000
if (config._a[HOUR] === 24 &&
        config._a[MINUTE] === 0 &&
        config._a[SECOND] === 0 &&
        config._a[MILLISECOND] === 0) {
    config._nextDay = true;
    config._a[HOUR] = 0;
}

config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
// Apply timezone offset from input. The actual utcOffset can be changed
// with parseZone.
if (config._tzm != null) {
    config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
}

if (config._nextDay) {
    config._a[HOUR] = 24;
}

}

function dayOfYearFromWeekInfo(config) {

var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;

w = config._w;
if (w.GG != null || w.W != null || w.E != null) {
    dow = 1;
    doy = 4;

    // TODO: We need to take the current isoWeekYear, but that depends on
    // how we interpret now (local, utc, fixed offset). So create
    // a now version of current config (take local/utc/offset flags, and
    // create now).
    weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
    week = defaults(w.W, 1);
    weekday = defaults(w.E, 1);
    if (weekday < 1 || weekday > 7) {
        weekdayOverflow = true;
    }
} else {
    dow = config._locale._week.dow;
    doy = config._locale._week.doy;

    var curWeek = weekOfYear(createLocal(), dow, doy);

    weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);

    // Default to current week.
    week = defaults(w.w, curWeek.week);

    if (w.d != null) {
        // weekday -- low day numbers are considered next week
        weekday = w.d;
        if (weekday < 0 || weekday > 6) {
            weekdayOverflow = true;
        }
    } else if (w.e != null) {
        // local weekday -- counting starts from begining of week
        weekday = w.e + dow;
        if (w.e < 0 || w.e > 6) {
            weekdayOverflow = true;
        }
    } else {
        // default to begining of week
        weekday = dow;
    }
}
if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
    getParsingFlags(config)._overflowWeeks = true;
} else if (weekdayOverflow != null) {
    getParsingFlags(config)._overflowWeekday = true;
} else {
    temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
    config._a[YEAR] = temp.year;
    config._dayOfYear = temp.dayOfYear;
}

}

// constant that refers to the ISO standard hooks.ISO_8601 = function () {};

// constant that refers to the RFC 2822 form hooks.RFC_2822 = function () {};

// date from string and format string function configFromStringAndFormat(config) {

// TODO: Move this to another part of the creation flow to prevent circular deps
if (config._f === hooks.ISO_8601) {
    configFromISO(config);
    return;
}
if (config._f === hooks.RFC_2822) {
    configFromRFC2822(config);
    return;
}
config._a = [];
getParsingFlags(config).empty = true;

// This array is used to make a Date, either with `new Date` or `Date.UTC`
var string = '' + config._i,
    i, parsedInput, tokens, token, skipped,
    stringLength = string.length,
    totalParsedInputLength = 0;

tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];

for (i = 0; i < tokens.length; i++) {
    token = tokens[i];
    parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
    // console.log('token', token, 'parsedInput', parsedInput,
    //         'regex', getParseRegexForToken(token, config));
    if (parsedInput) {
        skipped = string.substr(0, string.indexOf(parsedInput));
        if (skipped.length > 0) {
            getParsingFlags(config).unusedInput.push(skipped);
        }
        string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
        totalParsedInputLength += parsedInput.length;
    }
    // don't parse if it's not a known token
    if (formatTokenFunctions[token]) {
        if (parsedInput) {
            getParsingFlags(config).empty = false;
        }
        else {
            getParsingFlags(config).unusedTokens.push(token);
        }
        addTimeToArrayFromToken(token, parsedInput, config);
    }
    else if (config._strict && !parsedInput) {
        getParsingFlags(config).unusedTokens.push(token);
    }
}

// add remaining unparsed input length to the string
getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
if (string.length > 0) {
    getParsingFlags(config).unusedInput.push(string);
}

// clear _12h flag if hour is <= 12
if (config._a[HOUR] <= 12 &&
    getParsingFlags(config).bigHour === true &&
    config._a[HOUR] > 0) {
    getParsingFlags(config).bigHour = undefined;
}

getParsingFlags(config).parsedDateParts = config._a.slice(0);
getParsingFlags(config).meridiem = config._meridiem;
// handle meridiem
config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);

configFromArray(config);
checkOverflow(config);

}

function meridiemFixWrap (locale, hour, meridiem) {

var isPm;

if (meridiem == null) {
    // nothing to do
    return hour;
}
if (locale.meridiemHour != null) {
    return locale.meridiemHour(hour, meridiem);
} else if (locale.isPM != null) {
    // Fallback
    isPm = locale.isPM(meridiem);
    if (isPm && hour < 12) {
        hour += 12;
    }
    if (!isPm && hour === 12) {
        hour = 0;
    }
    return hour;
} else {
    // this is not supposed to happen
    return hour;
}

}

// date from string and array of format strings function configFromStringAndArray(config) {

var tempConfig,
    bestMoment,

    scoreToBeat,
    i,
    currentScore;

if (config._f.length === 0) {
    getParsingFlags(config).invalidFormat = true;
    config._d = new Date(NaN);
    return;
}

for (i = 0; i < config._f.length; i++) {
    currentScore = 0;
    tempConfig = copyConfig({}, config);
    if (config._useUTC != null) {
        tempConfig._useUTC = config._useUTC;
    }
    tempConfig._f = config._f[i];
    configFromStringAndFormat(tempConfig);

    if (!isValid(tempConfig)) {
        continue;
    }

    // if there is any input that was not parsed add a penalty for that format
    currentScore += getParsingFlags(tempConfig).charsLeftOver;

    //or tokens
    currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;

    getParsingFlags(tempConfig).score = currentScore;

    if (scoreToBeat == null || currentScore < scoreToBeat) {
        scoreToBeat = currentScore;
        bestMoment = tempConfig;
    }
}

extend(config, bestMoment || tempConfig);

}

function configFromObject(config) {

if (config._d) {
    return;
}

var i = normalizeObjectUnits(config._i);
config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
    return obj && parseInt(obj, 10);
});

configFromArray(config);

}

function createFromConfig (config) {

var res = new Moment(checkOverflow(prepareConfig(config)));
if (res._nextDay) {
    // Adding is smart enough around DST
    res.add(1, 'd');
    res._nextDay = undefined;
}

return res;

}

function prepareConfig (config) {

var input = config._i,
    format = config._f;

config._locale = config._locale || getLocale(config._l);

if (input === null || (format === undefined && input === '')) {
    return createInvalid({nullInput: true});
}

if (typeof input === 'string') {
    config._i = input = config._locale.preparse(input);
}

if (isMoment(input)) {
    return new Moment(checkOverflow(input));
} else if (isDate(input)) {
    config._d = input;
} else if (isArray(format)) {
    configFromStringAndArray(config);
} else if (format) {
    configFromStringAndFormat(config);
}  else {
    configFromInput(config);
}

if (!isValid(config)) {
    config._d = null;
}

return config;

}

function configFromInput(config) {

var input = config._i;
if (isUndefined(input)) {
    config._d = new Date(hooks.now());
} else if (isDate(input)) {
    config._d = new Date(input.valueOf());
} else if (typeof input === 'string') {
    configFromString(config);
} else if (isArray(input)) {
    config._a = map(input.slice(0), function (obj) {
        return parseInt(obj, 10);
    });
    configFromArray(config);
} else if (isObject(input)) {
    configFromObject(config);
} else if (isNumber(input)) {
    // from milliseconds
    config._d = new Date(input);
} else {
    hooks.createFromInputFallback(config);
}

}

function createLocalOrUTC (input, format, locale, strict, isUTC) {

var c = {};

if (locale === true || locale === false) {
    strict = locale;
    locale = undefined;
}

if ((isObject(input) && isObjectEmpty(input)) ||
        (isArray(input) && input.length === 0)) {
    input = undefined;
}
// object construction must be done this way.
// https://github.com/moment/moment/issues/1423
c._isAMomentObject = true;
c._useUTC = c._isUTC = isUTC;
c._l = locale;
c._i = input;
c._f = format;
c._strict = strict;

return createFromConfig(c);

}

function createLocal (input, format, locale, strict) {

return createLocalOrUTC(input, format, locale, strict, false);

}

var prototypeMin = deprecate(

'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
function () {
    var other = createLocal.apply(null, arguments);
    if (this.isValid() && other.isValid()) {
        return other < this ? this : other;
    } else {
        return createInvalid();
    }
}

);

var prototypeMax = deprecate(

'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
function () {
    var other = createLocal.apply(null, arguments);
    if (this.isValid() && other.isValid()) {
        return other > this ? this : other;
    } else {
        return createInvalid();
    }
}

);

// Pick a moment m from moments so that m(other) is true for all // other. This relies on the function fn to be transitive. // // moments should either be an array of moment objects or an array, whose // first element is an array of moment objects. function pickBy(fn, moments) {

var res, i;
if (moments.length === 1 && isArray(moments[0])) {
    moments = moments[0];
}
if (!moments.length) {
    return createLocal();
}
res = moments[0];
for (i = 1; i < moments.length; ++i) {
    if (!moments[i].isValid() || moments[i][fn](res)) {
        res = moments[i];
    }
}
return res;

}

// TODO: Use [].sort instead? function min () {

var args = [].slice.call(arguments, 0);

return pickBy('isBefore', args);

}

function max () {

var args = [].slice.call(arguments, 0);

return pickBy('isAfter', args);

}

var now = function () {

return Date.now ? Date.now() : +(new Date());

};

var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];

function isDurationValid(m) {

for (var key in m) {
    if (!(ordering.indexOf(key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
        return false;
    }
}

var unitHasDecimal = false;
for (var i = 0; i < ordering.length; ++i) {
    if (m[ordering[i]]) {
        if (unitHasDecimal) {
            return false; // only allow non-integers for smallest unit
        }
        if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
            unitHasDecimal = true;
        }
    }
}

return true;

}

function isValid$1() {

return this._isValid;

}

function createInvalid$1() {

return createDuration(NaN);

}

function Duration (duration) {

var normalizedInput = normalizeObjectUnits(duration),
    years = normalizedInput.year || 0,
    quarters = normalizedInput.quarter || 0,
    months = normalizedInput.month || 0,
    weeks = normalizedInput.week || 0,
    days = normalizedInput.day || 0,
    hours = normalizedInput.hour || 0,
    minutes = normalizedInput.minute || 0,
    seconds = normalizedInput.second || 0,
    milliseconds = normalizedInput.millisecond || 0;

this._isValid = isDurationValid(normalizedInput);

// representation for dateAddRemove
this._milliseconds = +milliseconds +
    seconds * 1e3 + // 1000
    minutes * 6e4 + // 1000 * 60
    hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
// Because of dateAddRemove treats 24 hours as different from a
// day when working around DST, we need to store them separately
this._days = +days +
    weeks * 7;
// It is impossible translate months into days without knowing
// which months you are are talking about, so we have to store
// it separately.
this._months = +months +
    quarters * 3 +
    years * 12;

this._data = {};

this._locale = getLocale();

this._bubble();

}

function isDuration (obj) {

return obj instanceof Duration;

}

function absRound (number) {

if (number < 0) {
    return Math.round(-1 * number) * -1;
} else {
    return Math.round(number);
}

}

// FORMATTING

function offset (token, separator) {

addFormatToken(token, 0, 0, function () {
    var offset = this.utcOffset();
    var sign = '+';
    if (offset < 0) {
        offset = -offset;
        sign = '-';
    }
    return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
});

}

offset('Z', ':'); offset('ZZ', '');

// PARSING

addRegexToken('Z', matchShortOffset); addRegexToken('ZZ', matchShortOffset); addParseToken(['Z', 'ZZ'], function (input, array, config) {

config._useUTC = true;
config._tzm = offsetFromString(matchShortOffset, input);

});

// HELPERS

// timezone chunker // '+10:00' > ['10', '00'] // '-1530' > ['-15', '30'] var chunkOffset = /([+-]|dd)/gi;

function offsetFromString(matcher, string) {

var matches = (string || '').match(matcher);

if (matches === null) {
    return null;
}

var chunk   = matches[matches.length - 1] || [];
var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];
var minutes = +(parts[1] * 60) + toInt(parts[2]);

return minutes === 0 ?
  0 :
  parts[0] === '+' ? minutes : -minutes;

}

// Return a moment from input, that is local/utc/zone equivalent to model. function cloneWithOffset(input, model) {

var res, diff;
if (model._isUTC) {
    res = model.clone();
    diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
    // Use low-level api, because this fn is low-level api.
    res._d.setTime(res._d.valueOf() + diff);
    hooks.updateOffset(res, false);
    return res;
} else {
    return createLocal(input).local();
}

}

function getDateOffset (m) {

// On Firefox.24 Date#getTimezoneOffset returns a floating point.
// https://github.com/moment/moment/pull/1871
return -Math.round(m._d.getTimezoneOffset() / 15) * 15;

}

// HOOKS

// This function will be called whenever a moment is mutated. // It is intended to keep the offset in sync with the timezone. hooks.updateOffset = function () {};

// MOMENTS

// keepLocalTime = true means only change the timezone, without // affecting the local hour. So 5:31:26 +0300 –[utcOffset(2, true)]–> // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset // +0200, so we adjust the time as needed, to be valid. // // Keeping the time actually adds/subtracts (one hour) // from the actual represented time. That is why we call updateOffset // a second time. In case it wants us to change the offset again // _changeInProgress == true case, then we have to adjust, because // there is no such time in the given timezone. function getSetOffset (input, keepLocalTime, keepMinutes) {

var offset = this._offset || 0,
    localAdjust;
if (!this.isValid()) {
    return input != null ? this : NaN;
}
if (input != null) {
    if (typeof input === 'string') {
        input = offsetFromString(matchShortOffset, input);
        if (input === null) {
            return this;
        }
    } else if (Math.abs(input) < 16 && !keepMinutes) {
        input = input * 60;
    }
    if (!this._isUTC && keepLocalTime) {
        localAdjust = getDateOffset(this);
    }
    this._offset = input;
    this._isUTC = true;
    if (localAdjust != null) {
        this.add(localAdjust, 'm');
    }
    if (offset !== input) {
        if (!keepLocalTime || this._changeInProgress) {
            addSubtract(this, createDuration(input - offset, 'm'), 1, false);
        } else if (!this._changeInProgress) {
            this._changeInProgress = true;
            hooks.updateOffset(this, true);
            this._changeInProgress = null;
        }
    }
    return this;
} else {
    return this._isUTC ? offset : getDateOffset(this);
}

}

function getSetZone (input, keepLocalTime) {

if (input != null) {
    if (typeof input !== 'string') {
        input = -input;
    }

    this.utcOffset(input, keepLocalTime);

    return this;
} else {
    return -this.utcOffset();
}

}

function setOffsetToUTC (keepLocalTime) {

return this.utcOffset(0, keepLocalTime);

}

function setOffsetToLocal (keepLocalTime) {

if (this._isUTC) {
    this.utcOffset(0, keepLocalTime);
    this._isUTC = false;

    if (keepLocalTime) {
        this.subtract(getDateOffset(this), 'm');
    }
}
return this;

}

function setOffsetToParsedOffset () {

if (this._tzm != null) {
    this.utcOffset(this._tzm, false, true);
} else if (typeof this._i === 'string') {
    var tZone = offsetFromString(matchOffset, this._i);
    if (tZone != null) {
        this.utcOffset(tZone);
    }
    else {
        this.utcOffset(0, true);
    }
}
return this;

}

function hasAlignedHourOffset (input) {

if (!this.isValid()) {
    return false;
}
input = input ? createLocal(input).utcOffset() : 0;

return (this.utcOffset() - input) % 60 === 0;

}

function isDaylightSavingTime () {

return (
    this.utcOffset() > this.clone().month(0).utcOffset() ||
    this.utcOffset() > this.clone().month(5).utcOffset()
);

}

function isDaylightSavingTimeShifted () {

if (!isUndefined(this._isDSTShifted)) {
    return this._isDSTShifted;
}

var c = {};

copyConfig(c, this);
c = prepareConfig(c);

if (c._a) {
    var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
    this._isDSTShifted = this.isValid() &&
        compareArrays(c._a, other.toArray()) > 0;
} else {
    this._isDSTShifted = false;
}

return this._isDSTShifted;

}

function isLocal () {

return this.isValid() ? !this._isUTC : false;

}

function isUtcOffset () {

return this.isValid() ? this._isUTC : false;

}

function isUtc () {

return this.isValid() ? this._isUTC && this._offset === 0 : false;

}

// ASP.NET json date format regex var aspNetRegex = /^(-)?(?:(d*)[. ])?(d+):(d+)(?::(d+)(.d*)?)?$/;

// from docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere // and further modified to allow for strings containing both week and day var isoRegex = /^(-)?P(?:(-?*)Y)?(?:(-?*)M)?(?:(-?*)W)?(?:(-?*)D)?(?:T(?:(-?*)H)?(?:(-?*)M)?(?:(-?*)S)?)?$/;

function createDuration (input, key) {

var duration = input,
    // matching against regexp is expensive, do it on demand
    match = null,
    sign,
    ret,
    diffRes;

if (isDuration(input)) {
    duration = {
        ms : input._milliseconds,
        d  : input._days,
        M  : input._months
    };
} else if (isNumber(input)) {
    duration = {};
    if (key) {
        duration[key] = input;
    } else {
        duration.milliseconds = input;
    }
} else if (!!(match = aspNetRegex.exec(input))) {
    sign = (match[1] === '-') ? -1 : 1;
    duration = {
        y  : 0,
        d  : toInt(match[DATE])                         * sign,
        h  : toInt(match[HOUR])                         * sign,
        m  : toInt(match[MINUTE])                       * sign,
        s  : toInt(match[SECOND])                       * sign,
        ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match
    };
} else if (!!(match = isoRegex.exec(input))) {
    sign = (match[1] === '-') ? -1 : 1;
    duration = {
        y : parseIso(match[2], sign),
        M : parseIso(match[3], sign),
        w : parseIso(match[4], sign),
        d : parseIso(match[5], sign),
        h : parseIso(match[6], sign),
        m : parseIso(match[7], sign),
        s : parseIso(match[8], sign)
    };
} else if (duration == null) {// checks for null or undefined
    duration = {};
} else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
    diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));

    duration = {};
    duration.ms = diffRes.milliseconds;
    duration.M = diffRes.months;
}

ret = new Duration(duration);

if (isDuration(input) && hasOwnProp(input, '_locale')) {
    ret._locale = input._locale;
}

return ret;

}

createDuration.fn = Duration.prototype; createDuration.invalid = createInvalid$1;

function parseIso (inp, sign) {

// We'd normally use ~~inp for this, but unfortunately it also
// converts floats to ints.
// inp may be undefined, so careful calling replace on it.
var res = inp && parseFloat(inp.replace(',', '.'));
// apply sign while we're at it
return (isNaN(res) ? 0 : res) * sign;

}

function positiveMomentsDifference(base, other) {

var res = {milliseconds: 0, months: 0};

res.months = other.month() - base.month() +
    (other.year() - base.year()) * 12;
if (base.clone().add(res.months, 'M').isAfter(other)) {
    --res.months;
}

res.milliseconds = +other - +(base.clone().add(res.months, 'M'));

return res;

}

function momentsDifference(base, other) {

var res;
if (!(base.isValid() && other.isValid())) {
    return {milliseconds: 0, months: 0};
}

other = cloneWithOffset(other, base);
if (base.isBefore(other)) {
    res = positiveMomentsDifference(base, other);
} else {
    res = positiveMomentsDifference(other, base);
    res.milliseconds = -res.milliseconds;
    res.months = -res.months;
}

return res;

}

// TODO: remove 'name' arg after deprecation is removed function createAdder(direction, name) {

return function (val, period) {
    var dur, tmp;
    //invert the arguments, but complain about it
    if (period !== null && !isNaN(+period)) {
        deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +
        'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
        tmp = val; val = period; period = tmp;
    }

    val = typeof val === 'string' ? +val : val;
    dur = createDuration(val, period);
    addSubtract(this, dur, direction);
    return this;
};

}

function addSubtract (mom, duration, isAdding, updateOffset) {

var milliseconds = duration._milliseconds,
    days = absRound(duration._days),
    months = absRound(duration._months);

if (!mom.isValid()) {
    // No op
    return;
}

updateOffset = updateOffset == null ? true : updateOffset;

if (milliseconds) {
    mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
}
if (days) {
    set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
}
if (months) {
    setMonth(mom, get(mom, 'Month') + months * isAdding);
}
if (updateOffset) {
    hooks.updateOffset(mom, days || months);
}

}

var add = createAdder(1, 'add'); var subtract = createAdder(-1, 'subtract');

function getCalendarFormat(myMoment, now) {

var diff = myMoment.diff(now, 'days', true);
return diff < -6 ? 'sameElse' :
        diff < -1 ? 'lastWeek' :
        diff < 0 ? 'lastDay' :
        diff < 1 ? 'sameDay' :
        diff < 2 ? 'nextDay' :
        diff < 7 ? 'nextWeek' : 'sameElse';

}

function calendar$1 (time, formats) {

// We want to compare the start of today, vs this.
// Getting start-of-today depends on whether we're local/utc/offset or not.
var now = time || createLocal(),
    sod = cloneWithOffset(now, this).startOf('day'),
    format = hooks.calendarFormat(this, sod) || 'sameElse';

var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);

return this.format(output || this.localeData().calendar(format, this, createLocal(now)));

}

function clone () {

return new Moment(this);

}

function isAfter (input, units) {

var localInput = isMoment(input) ? input : createLocal(input);
if (!(this.isValid() && localInput.isValid())) {
    return false;
}
units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
if (units === 'millisecond') {
    return this.valueOf() > localInput.valueOf();
} else {
    return localInput.valueOf() < this.clone().startOf(units).valueOf();
}

}

function isBefore (input, units) {

var localInput = isMoment(input) ? input : createLocal(input);
if (!(this.isValid() && localInput.isValid())) {
    return false;
}
units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
if (units === 'millisecond') {
    return this.valueOf() < localInput.valueOf();
} else {
    return this.clone().endOf(units).valueOf() < localInput.valueOf();
}

}

function isBetween (from, to, units, inclusivity) {

inclusivity = inclusivity || '()';
return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&
    (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));

}

function isSame (input, units) {

var localInput = isMoment(input) ? input : createLocal(input),
    inputMs;
if (!(this.isValid() && localInput.isValid())) {
    return false;
}
units = normalizeUnits(units || 'millisecond');
if (units === 'millisecond') {
    return this.valueOf() === localInput.valueOf();
} else {
    inputMs = localInput.valueOf();
    return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
}

}

function isSameOrAfter (input, units) {

return this.isSame(input, units) || this.isAfter(input,units);

}

function isSameOrBefore (input, units) {

return this.isSame(input, units) || this.isBefore(input,units);

}

function diff (input, units, asFloat) {

var that,
    zoneDelta,
    delta, output;

if (!this.isValid()) {
    return NaN;
}

that = cloneWithOffset(input, this);

if (!that.isValid()) {
    return NaN;
}

zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;

units = normalizeUnits(units);

if (units === 'year' || units === 'month' || units === 'quarter') {
    output = monthDiff(this, that);
    if (units === 'quarter') {
        output = output / 3;
    } else if (units === 'year') {
        output = output / 12;
    }
} else {
    delta = this - that;
    output = units === 'second' ? delta / 1e3 : // 1000
        units === 'minute' ? delta / 6e4 : // 1000 * 60
        units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60
        units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
        units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
        delta;
}
return asFloat ? output : absFloor(output);

}

function monthDiff (a, b) {

// difference in months
var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
    // b is in (anchor - 1 month, anchor + 1 month)
    anchor = a.clone().add(wholeMonthDiff, 'months'),
    anchor2, adjust;

if (b - anchor < 0) {
    anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
    // linear across the month
    adjust = (b - anchor) / (anchor - anchor2);
} else {
    anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
    // linear across the month
    adjust = (b - anchor) / (anchor2 - anchor);
}

//check for negative zero, return zero if negative zero
return -(wholeMonthDiff + adjust) || 0;

}

hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ'; hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss';

function toString () {

return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');

}

function toISOString() {

if (!this.isValid()) {
    return null;
}
var m = this.clone().utc();
if (m.year() < 0 || m.year() > 9999) {
    return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
}
if (isFunction(Date.prototype.toISOString)) {
    // native implementation is ~50x faster, use it when we can
    return this.toDate().toISOString();
}
return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');

}

/**

* Return a human readable representation of a moment that can
* also be evaluated to get a new moment which is the same
*
* @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
*/

function inspect () {

if (!this.isValid()) {
    return 'moment.invalid(/* ' + this._i + ' */)';
}
var func = 'moment';
var zone = '';
if (!this.isLocal()) {
    func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
    zone = 'Z';
}
var prefix = '[' + func + '("]';
var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';
var datetime = '-MM-DD[T]HH:mm:ss.SSS';
var suffix = zone + '[")]';

return this.format(prefix + year + datetime + suffix);

}

function format (inputString) {

if (!inputString) {
    inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
}
var output = formatMoment(this, inputString);
return this.localeData().postformat(output);

}

function from (time, withoutSuffix) {

if (this.isValid() &&
        ((isMoment(time) && time.isValid()) ||
         createLocal(time).isValid())) {
    return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
} else {
    return this.localeData().invalidDate();
}

}

function fromNow (withoutSuffix) {

return this.from(createLocal(), withoutSuffix);

}

function to (time, withoutSuffix) {

if (this.isValid() &&
        ((isMoment(time) && time.isValid()) ||
         createLocal(time).isValid())) {
    return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
} else {
    return this.localeData().invalidDate();
}

}

function toNow (withoutSuffix) {

return this.to(createLocal(), withoutSuffix);

}

// If passed a locale key, it will set the locale for this // instance. Otherwise, it will return the locale configuration // variables for this instance. function locale (key) {

var newLocaleData;

if (key === undefined) {
    return this._locale._abbr;
} else {
    newLocaleData = getLocale(key);
    if (newLocaleData != null) {
        this._locale = newLocaleData;
    }
    return this;
}

}

var lang = deprecate(

'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
function (key) {
    if (key === undefined) {
        return this.localeData();
    } else {
        return this.locale(key);
    }
}

);

function localeData () {

return this._locale;

}

function startOf (units) {

units = normalizeUnits(units);
// the following switch intentionally omits break keywords
// to utilize falling through the cases.
switch (units) {
    case 'year':
        this.month(0);
        /* falls through */
    case 'quarter':
    case 'month':
        this.date(1);
        /* falls through */
    case 'week':
    case 'isoWeek':
    case 'day':
    case 'date':
        this.hours(0);
        /* falls through */
    case 'hour':
        this.minutes(0);
        /* falls through */
    case 'minute':
        this.seconds(0);
        /* falls through */
    case 'second':
        this.milliseconds(0);
}

// weeks are a special case
if (units === 'week') {
    this.weekday(0);
}
if (units === 'isoWeek') {
    this.isoWeekday(1);
}

// quarters are also special
if (units === 'quarter') {
    this.month(Math.floor(this.month() / 3) * 3);
}

return this;

}

function endOf (units) {

units = normalizeUnits(units);
if (units === undefined || units === 'millisecond') {
    return this;
}

// 'date' is an alias for 'day', so it should be considered as such.
if (units === 'date') {
    units = 'day';
}

return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');

}

function valueOf () {

return this._d.valueOf() - ((this._offset || 0) * 60000);

}

function unix () {

return Math.floor(this.valueOf() / 1000);

}

function toDate () {

return new Date(this.valueOf());

}

function toArray () {

var m = this;
return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];

}

function toObject () {

var m = this;
return {
    years: m.year(),
    months: m.month(),
    date: m.date(),
    hours: m.hours(),
    minutes: m.minutes(),
    seconds: m.seconds(),
    milliseconds: m.milliseconds()
};

}

function toJSON () {

// new Date(NaN).toJSON() === null
return this.isValid() ? this.toISOString() : null;

}

function isValid$2 () {

return isValid(this);

}

function parsingFlags () {

return extend({}, getParsingFlags(this));

}

function invalidAt () {

return getParsingFlags(this).overflow;

}

function creationData() {

return {
    input: this._i,
    format: this._f,
    locale: this._locale,
    isUTC: this._isUTC,
    strict: this._strict
};

}

// FORMATTING

addFormatToken(0, ['gg', 2], 0, function () {

return this.weekYear() % 100;

});

addFormatToken(0, ['GG', 2], 0, function () {

return this.isoWeekYear() % 100;

});

function addWeekYearFormatToken (token, getter) {

addFormatToken(0, [token, token.length], 0, getter);

}

addWeekYearFormatToken('gggg', 'weekYear'); addWeekYearFormatToken('ggggg', 'weekYear'); addWeekYearFormatToken('GGGG', 'isoWeekYear'); addWeekYearFormatToken('GGGGG', 'isoWeekYear');

// ALIASES

addUnitAlias('weekYear', 'gg'); addUnitAlias('isoWeekYear', 'GG');

// PRIORITY

addUnitPriority('weekYear', 1); addUnitPriority('isoWeekYear', 1);

// PARSING

addRegexToken('G', matchSigned); addRegexToken('g', matchSigned); addRegexToken('GG', match1to2, match2); addRegexToken('gg', match1to2, match2); addRegexToken('GGGG', match1to4, match4); addRegexToken('gggg', match1to4, match4); addRegexToken('GGGGG', match1to6, match6); addRegexToken('ggggg', match1to6, match6);

addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {

week[token.substr(0, 2)] = toInt(input);

});

addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {

week[token] = hooks.parseTwoDigitYear(input);

});

// MOMENTS

function getSetWeekYear (input) {

return getSetWeekYearHelper.call(this,
        input,
        this.week(),
        this.weekday(),
        this.localeData()._week.dow,
        this.localeData()._week.doy);

}

function getSetISOWeekYear (input) {

return getSetWeekYearHelper.call(this,
        input, this.isoWeek(), this.isoWeekday(), 1, 4);

}

function getISOWeeksInYear () {

return weeksInYear(this.year(), 1, 4);

}

function getWeeksInYear () {

var weekInfo = this.localeData()._week;
return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);

}

function getSetWeekYearHelper(input, week, weekday, dow, doy) {

var weeksTarget;
if (input == null) {
    return weekOfYear(this, dow, doy).year;
} else {
    weeksTarget = weeksInYear(input, dow, doy);
    if (week > weeksTarget) {
        week = weeksTarget;
    }
    return setWeekAll.call(this, input, week, weekday, dow, doy);
}

}

function setWeekAll(weekYear, week, weekday, dow, doy) {

var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
    date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);

this.year(date.getUTCFullYear());
this.month(date.getUTCMonth());
this.date(date.getUTCDate());
return this;

}

// FORMATTING

addFormatToken('Q', 0, 'Qo', 'quarter');

// ALIASES

addUnitAlias('quarter', 'Q');

// PRIORITY

addUnitPriority('quarter', 7);

// PARSING

addRegexToken('Q', match1); addParseToken('Q', function (input, array) {

array[MONTH] = (toInt(input) - 1) * 3;

});

// MOMENTS

function getSetQuarter (input) {

return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);

}

// FORMATTING

addFormatToken('D', ['DD', 2], 'Do', 'date');

// ALIASES

addUnitAlias('date', 'D');

// PRIOROITY addUnitPriority('date', 9);

// PARSING

addRegexToken('D', match1to2); addRegexToken('DD', match1to2, match2); addRegexToken('Do', function (isStrict, locale) {

// TODO: Remove "ordinalParse" fallback in next major release.
return isStrict ?
  (locale._dayOfMonthOrdinalParse || locale._ordinalParse) :
  locale._dayOfMonthOrdinalParseLenient;

});

addParseToken(['D', 'DD'], DATE); addParseToken('Do', function (input, array) {

array[DATE] = toInt(input.match(match1to2)[0], 10);

});

// MOMENTS

var getSetDayOfMonth = makeGetSet('Date', true);

// FORMATTING

addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');

// ALIASES

addUnitAlias('dayOfYear', 'DDD');

// PRIORITY addUnitPriority('dayOfYear', 4);

// PARSING

addRegexToken('DDD', match1to3); addRegexToken('DDDD', match3); addParseToken(['DDD', 'DDDD'], function (input, array, config) {

config._dayOfYear = toInt(input);

});

// HELPERS

// MOMENTS

function getSetDayOfYear (input) {

var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');

}

// FORMATTING

addFormatToken('m', ['mm', 2], 0, 'minute');

// ALIASES

addUnitAlias('minute', 'm');

// PRIORITY

addUnitPriority('minute', 14);

// PARSING

addRegexToken('m', match1to2); addRegexToken('mm', match1to2, match2); addParseToken(['m', 'mm'], MINUTE);

// MOMENTS

var getSetMinute = makeGetSet('Minutes', false);

// FORMATTING

addFormatToken('s', ['ss', 2], 0, 'second');

// ALIASES

addUnitAlias('second', 's');

// PRIORITY

addUnitPriority('second', 15);

// PARSING

addRegexToken('s', match1to2); addRegexToken('ss', match1to2, match2); addParseToken(['s', 'ss'], SECOND);

// MOMENTS

var getSetSecond = makeGetSet('Seconds', false);

// FORMATTING

addFormatToken('S', 0, 0, function () {

return ~~(this.millisecond() / 100);

});

addFormatToken(0, ['SS', 2], 0, function () {

return ~~(this.millisecond() / 10);

});

addFormatToken(0, ['SSS', 3], 0, 'millisecond'); addFormatToken(0, ['SSSS', 4], 0, function () {

return this.millisecond() * 10;

}); addFormatToken(0, ['SSSSS', 5], 0, function () {

return this.millisecond() * 100;

}); addFormatToken(0, ['SSSSSS', 6], 0, function () {

return this.millisecond() * 1000;

}); addFormatToken(0, ['SSSSSSS', 7], 0, function () {

return this.millisecond() * 10000;

}); addFormatToken(0, ['SSSSSSSS', 8], 0, function () {

return this.millisecond() * 100000;

}); addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {

return this.millisecond() * 1000000;

});

// ALIASES

addUnitAlias('millisecond', 'ms');

// PRIORITY

addUnitPriority('millisecond', 16);

// PARSING

addRegexToken('S', match1to3, match1); addRegexToken('SS', match1to3, match2); addRegexToken('SSS', match1to3, match3);

var token; for (token = 'SSSS'; token.length <= 9; token += 'S') {

addRegexToken(token, matchUnsigned);

}

function parseMs(input, array) {

array[MILLISECOND] = toInt(('0.' + input) * 1000);

}

for (token = 'S'; token.length <= 9; token += 'S') {

addParseToken(token, parseMs);

} // MOMENTS

var getSetMillisecond = makeGetSet('Milliseconds', false);

// FORMATTING

addFormatToken('z', 0, 0, 'zoneAbbr'); addFormatToken('zz', 0, 0, 'zoneName');

// MOMENTS

function getZoneAbbr () {

return this._isUTC ? 'UTC' : '';

}

function getZoneName () {

return this._isUTC ? 'Coordinated Universal Time' : '';

}

var proto = Moment.prototype;

proto.add = add; proto.calendar = calendar$1; proto.clone = clone; proto.diff = diff; proto.endOf = endOf; proto.format = format; proto.from = from; proto.fromNow = fromNow; proto.to = to; proto.toNow = toNow; proto.get = stringGet; proto.invalidAt = invalidAt; proto.isAfter = isAfter; proto.isBefore = isBefore; proto.isBetween = isBetween; proto.isSame = isSame; proto.isSameOrAfter = isSameOrAfter; proto.isSameOrBefore = isSameOrBefore; proto.isValid = isValid$2; proto.lang = lang; proto.locale = locale; proto.localeData = localeData; proto.max = prototypeMax; proto.min = prototypeMin; proto.parsingFlags = parsingFlags; proto.set = stringSet; proto.startOf = startOf; proto.subtract = subtract; proto.toArray = toArray; proto.toObject = toObject; proto.toDate = toDate; proto.toISOString = toISOString; proto.inspect = inspect; proto.toJSON = toJSON; proto.toString = toString; proto.unix = unix; proto.valueOf = valueOf; proto.creationData = creationData;

// Year proto.year = getSetYear; proto.isLeapYear = getIsLeapYear;

// Week Year proto.weekYear = getSetWeekYear; proto.isoWeekYear = getSetISOWeekYear;

// Quarter proto.quarter = proto.quarters = getSetQuarter;

// Month proto.month = getSetMonth; proto.daysInMonth = getDaysInMonth;

// Week proto.week = proto.weeks = getSetWeek; proto.isoWeek = proto.isoWeeks = getSetISOWeek; proto.weeksInYear = getWeeksInYear; proto.isoWeeksInYear = getISOWeeksInYear;

// Day proto.date = getSetDayOfMonth; proto.day = proto.days = getSetDayOfWeek; proto.weekday = getSetLocaleDayOfWeek; proto.isoWeekday = getSetISODayOfWeek; proto.dayOfYear = getSetDayOfYear;

// Hour proto.hour = proto.hours = getSetHour;

// Minute proto.minute = proto.minutes = getSetMinute;

// Second proto.second = proto.seconds = getSetSecond;

// Millisecond proto.millisecond = proto.milliseconds = getSetMillisecond;

// Offset proto.utcOffset = getSetOffset; proto.utc = setOffsetToUTC; proto.local = setOffsetToLocal; proto.parseZone = setOffsetToParsedOffset; proto.hasAlignedHourOffset = hasAlignedHourOffset; proto.isDST = isDaylightSavingTime; proto.isLocal = isLocal; proto.isUtcOffset = isUtcOffset; proto.isUtc = isUtc; proto.isUTC = isUtc;

// Timezone proto.zoneAbbr = getZoneAbbr; proto.zoneName = getZoneName;

// Deprecations proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth); proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth); proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear); proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. momentjs.com/guides/#/warnings/zone/', getSetZone); proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);

function createUnix (input) {

return createLocal(input * 1000);

}

function createInZone () {

return createLocal.apply(null, arguments).parseZone();

}

function preParsePostFormat (string) {

return string;

}

var proto$1 = Locale.prototype;

proto$1.calendar = calendar; proto$1.longDateFormat = longDateFormat; proto$1.invalidDate = invalidDate; proto$1.ordinal = ordinal; proto$1.preparse = preParsePostFormat; proto$1.postformat = preParsePostFormat; proto$1.relativeTime = relativeTime; proto$1.pastFuture = pastFuture; proto$1.set = set;

// Month proto$1.months = localeMonths; proto$1.monthsShort = localeMonthsShort; proto$1.monthsParse = localeMonthsParse; proto$1.monthsRegex = monthsRegex; proto$1.monthsShortRegex = monthsShortRegex;

// Week proto$1.week = localeWeek; proto$1.firstDayOfYear = localeFirstDayOfYear; proto$1.firstDayOfWeek = localeFirstDayOfWeek;

// Day of Week proto$1.weekdays = localeWeekdays; proto$1.weekdaysMin = localeWeekdaysMin; proto$1.weekdaysShort = localeWeekdaysShort; proto$1.weekdaysParse = localeWeekdaysParse;

proto$1.weekdaysRegex = weekdaysRegex; proto$1.weekdaysShortRegex = weekdaysShortRegex; proto$1.weekdaysMinRegex = weekdaysMinRegex;

// Hours proto$1.isPM = localeIsPM; proto$1.meridiem = localeMeridiem;

function get$1 (format, index, field, setter) {

var locale = getLocale();
var utc = createUTC().set(setter, index);
return locale[field](utc, format);

}

function listMonthsImpl (format, index, field) {

if (isNumber(format)) {
    index = format;
    format = undefined;
}

format = format || '';

if (index != null) {
    return get$1(format, index, field, 'month');
}

var i;
var out = [];
for (i = 0; i < 12; i++) {
    out[i] = get$1(format, i, field, 'month');
}
return out;

}

// () // (5) // (fmt, 5) // (fmt) // (true) // (true, 5) // (true, fmt, 5) // (true, fmt) function listWeekdaysImpl (localeSorted, format, index, field) {

if (typeof localeSorted === 'boolean') {
    if (isNumber(format)) {
        index = format;
        format = undefined;
    }

    format = format || '';
} else {
    format = localeSorted;
    index = format;
    localeSorted = false;

    if (isNumber(format)) {
        index = format;
        format = undefined;
    }

    format = format || '';
}

var locale = getLocale(),
    shift = localeSorted ? locale._week.dow : 0;

if (index != null) {
    return get$1(format, (index + shift) % 7, field, 'day');
}

var i;
var out = [];
for (i = 0; i < 7; i++) {
    out[i] = get$1(format, (i + shift) % 7, field, 'day');
}
return out;

}

function listMonths (format, index) {

return listMonthsImpl(format, index, 'months');

}

function listMonthsShort (format, index) {

return listMonthsImpl(format, index, 'monthsShort');

}

function listWeekdays (localeSorted, format, index) {

return listWeekdaysImpl(localeSorted, format, index, 'weekdays');

}

function listWeekdaysShort (localeSorted, format, index) {

return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');

}

function listWeekdaysMin (localeSorted, format, index) {

return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');

}

getSetGlobalLocale('en', {

dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
ordinal : function (number) {
    var b = number % 10,
        output = (toInt(number % 100 / 10) === 1) ? 'th' :
        (b === 1) ? 'st' :
        (b === 2) ? 'nd' :
        (b === 3) ? 'rd' : 'th';
    return number + output;
}

});

// Side effect imports hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale); hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);

var mathAbs = Math.abs;

function abs () {

var data           = this._data;

this._milliseconds = mathAbs(this._milliseconds);
this._days         = mathAbs(this._days);
this._months       = mathAbs(this._months);

data.milliseconds  = mathAbs(data.milliseconds);
data.seconds       = mathAbs(data.seconds);
data.minutes       = mathAbs(data.minutes);
data.hours         = mathAbs(data.hours);
data.months        = mathAbs(data.months);
data.years         = mathAbs(data.years);

return this;

}

function addSubtract$1 (duration, input, value, direction) {

var other = createDuration(input, value);

duration._milliseconds += direction * other._milliseconds;
duration._days         += direction * other._days;
duration._months       += direction * other._months;

return duration._bubble();

}

// supports only 2.0-style add(1, 's') or add(duration) function add$1 (input, value) {

return addSubtract$1(this, input, value, 1);

}

// supports only 2.0-style subtract(1, 's') or subtract(duration) function subtract$1 (input, value) {

return addSubtract$1(this, input, value, -1);

}

function absCeil (number) {

if (number < 0) {
    return Math.floor(number);
} else {
    return Math.ceil(number);
}

}

function bubble () {

var milliseconds = this._milliseconds;
var days         = this._days;
var months       = this._months;
var data         = this._data;
var seconds, minutes, hours, years, monthsFromDays;

// if we have a mix of positive and negative values, bubble down first
// check: https://github.com/moment/moment/issues/2166
if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
        (milliseconds <= 0 && days <= 0 && months <= 0))) {
    milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
    days = 0;
    months = 0;
}

// The following code bubbles up values, see the tests for
// examples of what that means.
data.milliseconds = milliseconds % 1000;

seconds           = absFloor(milliseconds / 1000);
data.seconds      = seconds % 60;

minutes           = absFloor(seconds / 60);
data.minutes      = minutes % 60;

hours             = absFloor(minutes / 60);
data.hours        = hours % 24;

days += absFloor(hours / 24);

// convert days to months
monthsFromDays = absFloor(daysToMonths(days));
months += monthsFromDays;
days -= absCeil(monthsToDays(monthsFromDays));

// 12 months -> 1 year
years = absFloor(months / 12);
months %= 12;

data.days   = days;
data.months = months;
data.years  = years;

return this;

}

function daysToMonths (days) {

// 400 years have 146097 days (taking into account leap year rules)
// 400 years have 12 months === 4800
return days * 4800 / 146097;

}

function monthsToDays (months) {

// the reverse of daysToMonths
return months * 146097 / 4800;

}

function as (units) {

if (!this.isValid()) {
    return NaN;
}
var days;
var months;
var milliseconds = this._milliseconds;

units = normalizeUnits(units);

if (units === 'month' || units === 'year') {
    days   = this._days   + milliseconds / 864e5;
    months = this._months + daysToMonths(days);
    return units === 'month' ? months : months / 12;
} else {
    // handle milliseconds separately because of floating point math errors (issue #1867)
    days = this._days + Math.round(monthsToDays(this._months));
    switch (units) {
        case 'week'   : return days / 7     + milliseconds / 6048e5;
        case 'day'    : return days         + milliseconds / 864e5;
        case 'hour'   : return days * 24    + milliseconds / 36e5;
        case 'minute' : return days * 1440  + milliseconds / 6e4;
        case 'second' : return days * 86400 + milliseconds / 1000;
        // Math.floor prevents floating point math errors here
        case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
        default: throw new Error('Unknown unit ' + units);
    }
}

}

// TODO: Use this.as('ms')? function valueOf$1 () {

if (!this.isValid()) {
    return NaN;
}
return (
    this._milliseconds +
    this._days * 864e5 +
    (this._months % 12) * 2592e6 +
    toInt(this._months / 12) * 31536e6
);

}

function makeAs (alias) {

return function () {
    return this.as(alias);
};

}

var asMilliseconds = makeAs('ms'); var asSeconds = makeAs('s'); var asMinutes = makeAs('m'); var asHours = makeAs('h'); var asDays = makeAs('d'); var asWeeks = makeAs('w'); var asMonths = makeAs('M'); var asYears = makeAs('y');

function get$2 (units) {

units = normalizeUnits(units);
return this.isValid() ? this[units + 's']() : NaN;

}

function makeGetter(name) {

return function () {
    return this.isValid() ? this._data[name] : NaN;
};

}

var milliseconds = makeGetter('milliseconds'); var seconds = makeGetter('seconds'); var minutes = makeGetter('minutes'); var hours = makeGetter('hours'); var days = makeGetter('days'); var months = makeGetter('months'); var years = makeGetter('years');

function weeks () {

return absFloor(this.days() / 7);

}

var round = Math.round; var thresholds = {

ss: 44,         // a few seconds to seconds
s : 45,         // seconds to minute
m : 45,         // minutes to hour
h : 22,         // hours to day
d : 26,         // days to month
M : 11          // months to year

};

// helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {

return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);

}

function relativeTime$1 (posNegDuration, withoutSuffix, locale) {

var duration = createDuration(posNegDuration).abs();
var seconds  = round(duration.as('s'));
var minutes  = round(duration.as('m'));
var hours    = round(duration.as('h'));
var days     = round(duration.as('d'));
var months   = round(duration.as('M'));
var years    = round(duration.as('y'));

var a = seconds <= thresholds.ss && ['s', seconds]  ||
        seconds < thresholds.s   && ['ss', seconds] ||
        minutes <= 1             && ['m']           ||
        minutes < thresholds.m   && ['mm', minutes] ||
        hours   <= 1             && ['h']           ||
        hours   < thresholds.h   && ['hh', hours]   ||
        days    <= 1             && ['d']           ||
        days    < thresholds.d   && ['dd', days]    ||
        months  <= 1             && ['M']           ||
        months  < thresholds.M   && ['MM', months]  ||
        years   <= 1             && ['y']           || ['yy', years];

a[2] = withoutSuffix;
a[3] = +posNegDuration > 0;
a[4] = locale;
return substituteTimeAgo.apply(null, a);

}

// This function allows you to set the rounding function for relative time strings function getSetRelativeTimeRounding (roundingFunction) {

if (roundingFunction === undefined) {
    return round;
}
if (typeof(roundingFunction) === 'function') {
    round = roundingFunction;
    return true;
}
return false;

}

// This function allows you to set a threshold for relative time strings function getSetRelativeTimeThreshold (threshold, limit) {

if (thresholds[threshold] === undefined) {
    return false;
}
if (limit === undefined) {
    return thresholds[threshold];
}
thresholds[threshold] = limit;
if (threshold === 's') {
    thresholds.ss = limit - 1;
}
return true;

}

function humanize (withSuffix) {

if (!this.isValid()) {
    return this.localeData().invalidDate();
}

var locale = this.localeData();
var output = relativeTime$1(this, !withSuffix, locale);

if (withSuffix) {
    output = locale.pastFuture(+this, output);
}

return locale.postformat(output);

}

var abs$1 = Math.abs;

function toISOString$1() {

// for ISO strings we do not use the normal bubbling rules:
//  * milliseconds bubble up until they become hours
//  * days do not bubble at all
//  * months bubble up until they become years
// This is because there is no context-free conversion between hours and days
// (think of clock changes)
// and also not between days and months (28-31 days per month)
if (!this.isValid()) {
    return this.localeData().invalidDate();
}

var seconds = abs$1(this._milliseconds) / 1000;
var days         = abs$1(this._days);
var months       = abs$1(this._months);
var minutes, hours, years;

// 3600 seconds -> 60 minutes -> 1 hour
minutes           = absFloor(seconds / 60);
hours             = absFloor(minutes / 60);
seconds %= 60;
minutes %= 60;

// 12 months -> 1 year
years  = absFloor(months / 12);
months %= 12;

// inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
var Y = years;
var M = months;
var D = days;
var h = hours;
var m = minutes;
var s = seconds;
var total = this.asSeconds();

if (!total) {
    // this is the same as C#'s (Noda) and python (isodate)...
    // but not other JS (goog.date)
    return 'P0D';
}

return (total < 0 ? '-' : '') +
    'P' +
    (Y ? Y + 'Y' : '') +
    (M ? M + 'M' : '') +
    (D ? D + 'D' : '') +
    ((h || m || s) ? 'T' : '') +
    (h ? h + 'H' : '') +
    (m ? m + 'M' : '') +
    (s ? s + 'S' : '');

}

var proto$2 = Duration.prototype;

proto$2.isValid = isValid$1; proto$2.abs = abs; proto$2.add = add$1; proto$2.subtract = subtract$1; proto$2.as = as; proto$2.asMilliseconds = asMilliseconds; proto$2.asSeconds = asSeconds; proto$2.asMinutes = asMinutes; proto$2.asHours = asHours; proto$2.asDays = asDays; proto$2.asWeeks = asWeeks; proto$2.asMonths = asMonths; proto$2.asYears = asYears; proto$2.valueOf = valueOf$1; proto$2._bubble = bubble; proto$2.get = get$2; proto$2.milliseconds = milliseconds; proto$2.seconds = seconds; proto$2.minutes = minutes; proto$2.hours = hours; proto$2.days = days; proto$2.weeks = weeks; proto$2.months = months; proto$2.years = years; proto$2.humanize = humanize; proto$2.toISOString = toISOString$1; proto$2.toString = toISOString$1; proto$2.toJSON = toISOString$1; proto$2.locale = locale; proto$2.localeData = localeData;

// Deprecations proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1); proto$2.lang = lang;

// Side effect imports

// FORMATTING

addFormatToken('X', 0, 0, 'unix'); addFormatToken('x', 0, 0, 'valueOf');

// PARSING

addRegexToken('x', matchSigned); addRegexToken('X', matchTimestamp); addParseToken('X', function (input, array, config) {

config._d = new Date(parseFloat(input, 10) * 1000);

}); addParseToken('x', function (input, array, config) {

config._d = new Date(toInt(input));

});

// Side effect imports

hooks.version = '2.18.1';

setHookCallback(createLocal);

hooks.fn = proto; hooks.min = min; hooks.max = max; hooks.now = now; hooks.utc = createUTC; hooks.unix = createUnix; hooks.months = listMonths; hooks.isDate = isDate; hooks.locale = getSetGlobalLocale; hooks.invalid = createInvalid; hooks.duration = createDuration; hooks.isMoment = isMoment; hooks.weekdays = listWeekdays; hooks.parseZone = createInZone; hooks.localeData = getLocale; hooks.isDuration = isDuration; hooks.monthsShort = listMonthsShort; hooks.weekdaysMin = listWeekdaysMin; hooks.defineLocale = defineLocale; hooks.updateLocale = updateLocale; hooks.locales = listLocales; hooks.weekdaysShort = listWeekdaysShort; hooks.normalizeUnits = normalizeUnits; hooks.relativeTimeRounding = getSetRelativeTimeRounding; hooks.relativeTimeThreshold = getSetRelativeTimeThreshold; hooks.calendarFormat = getCalendarFormat; hooks.prototype = proto;

return hooks;

})));

/* WEBPACK VAR INJECTION */}.call(exports, webpack_require(3)(module)))

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.setLogLevel = exports.logger = exports.LEVELS = undefined;

var _moment = webpack_require(0);

var _moment2 = _interopRequireDefault(_moment);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var LEVELS = exports.LEVELS = {

debug: 1,
info: 2,
warn: 3,
error: 4,
fatal: 5

};

var logger = exports.logger = {

debug: function debug() {},
info: function info() {},
warn: function warn() {},
error: function error() {},
fatal: function fatal() {}

};

var setLogLevel = exports.setLogLevel = function setLogLevel(level) {

logger.debug = function () {};
logger.info = function () {};
logger.warn = function () {};
logger.error = function () {};
logger.fatal = function () {};
if (level <= LEVELS.fatal) {
  logger.fatal = console.log.bind(console, '\x1b[35m', format('FATAL'));
}
if (level <= LEVELS.error) {
  logger.error = console.log.bind(console, '\x1b[31m', format('ERROR'));
}
if (level <= LEVELS.warn) {
  logger.warn = console.log.bind(console, '\x1B[33m', format('WARN'));
}
if (level <= LEVELS.info) {
  logger.info = console.log.bind(console, '\x1b[34m', format('INFO'));
}
if (level <= LEVELS.debug) {
  logger.debug = console.log.bind(console, '\x1b[32m', format('DEBUG'));
}

};

var format = function format(level) {

var time = (0, _moment2.default)().format('HH:mm:ss.SSS');
return time + ' : ' + level + ' : ';

};

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

/**

* Checks if `value` is classified as an `Array` object.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an array, else `false`.
* @example
*
* _.isArray([1, 2, 3]);
* // => true
*
* _.isArray(document.body.children);
* // => false
*
* _.isArray('abc');
* // => false
*
* _.isArray(_.noop);
* // => false
*/

var isArray = Array.isArray;

module.exports = isArray;

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

module.exports = function(module) {

if(!module.webpackPolyfill) {
        module.deprecate = function() {};
        module.paths = [];
        // module.parent = undefined by default
        if(!module.children) module.children = [];
        Object.defineProperty(module, "loaded", {
                enumerable: true,
                get: function() {
                        return module.l;
                }
        });
        Object.defineProperty(module, "id", {
                enumerable: true,
                get: function() {
                        return module.i;
                }
        });
        module.webpackPolyfill = 1;
}
return module;

};

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

/* global window */

var lodash;

if (true) {

try {
  lodash = __webpack_require__(17);
} catch (e) {}

}

if (!lodash) {

lodash = window._;

}

module.exports = lodash;

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

var freeGlobal = webpack_require(176);

/** 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')();

module.exports = root;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _typeof = typeof Symbol === “function” && typeof Symbol.iterator === “symbol” ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === “function” && obj.constructor === Symbol && obj !== Symbol.prototype ? “symbol” : typeof obj; };

var _d = webpack_require(29);

var _d2 = _interopRequireDefault(_d);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

D3 Text Wrap
By Vijith Assar
http://www.vijithassar.com
http://www.github.com/vijithassar
@vijithassar

Detailed instructions at http://www.github.com/vijithassar/d3textwrap
*/

(function () {

// set this variable to a string value to always force a particular
// wrap method for development purposes, for example to check tspan
// rendering using a foreignobject-enabled browser. set to 'tspan' to
// use tspans and 'foreignobject' to use foreignobject
var forceWrapMethod = false; // by default no wrap method is forced
forceWrapMethod = 'tspans'; // uncomment this statement to force tspans
// force_wrap_method = 'foreignobjects'; // uncomment this statement to force foreignobjects

// exit immediately if something in this location
// has already been defined; the plugin will defer to whatever
// else you're doing in your code
if (_d2.default.selection.prototype.textwrap) {
  return false;
}

// double check the force_wrap_method flag
// and reset if someone screwed up the above
// settings
if (typeof forceWrapMethod === 'undefined') {
  forceWrapMethod = false;
}

// create the plugin method twice, both for regular use
// and again for use inside the enter() selection
_d2.default.selection.prototype.textwrap = _d2.default.selection.enter.prototype.textwrap = function (bounds, padding) {
  // default value of padding is zero if it's undefined
  padding = parseInt(padding) || 0;

  // save callee into a variable so we can continue to refer to it
  // as the function scope changes
  var selection = this;

  // create a variable to store desired return values in
  var returnValue;

  // extract wrap boundaries from any d3-selected rect and return them
  // in a format that matches the simpler object argument option
  var extractBounds = function extractBounds(bounds) {
    // discard the nested array wrappers added by d3
    var boundingRect = bounds[0][0];
    // sanitize the svg element name so we can test against it
    var elementType = boundingRect.tagName.toString();
    // if it's not a rect, exit
    if (elementType !== 'rect') {
      return false;
      // if it's a rect, proceed to extracting the position attributes
    } else {
      var boundsExtracted = {};
      boundsExtracted.x = _d2.default.select(boundingRect).attr('x') || 0;
      boundsExtracted.y = _d2.default.select(boundingRect).attr('y') || 0;
      boundsExtracted.width = _d2.default.select(boundingRect).attr('width') || 0;
      boundsExtracted.height = _d2.default.select(boundingRect).attr('height') || 0;
      // also pass along the getter function
      boundsExtracted.attr = bounds.attr;
    }
    return boundsExtracted;
  };

  // double check the input argument for the wrapping
  // boundaries to make sure it actually contains all
  // the information we'll need in order to wrap successfully
  var verifyBounds = function verifyBounds(bounds) {
    // quickly add a simple getter method so you can use either
    // bounds.x or bounds.attr('x') as your notation,
    // the latter being a common convention among D3
    // developers
    if (!bounds.attr) {
      bounds.attr = function (property) {
        if (this[property]) {
          return this[property];
        }
      };
    }
    // if it's an associative array, make sure it has all the
    // necessary properties represented directly
    if ((typeof bounds === 'undefined' ? 'undefined' : _typeof(bounds)) === 'object' && typeof bounds.x !== 'undefined' && typeof bounds.y !== 'undefined' && typeof bounds.width !== 'undefined' && typeof bounds.height !== 'undefined'
    // if that's the case, then the bounds are fine
    ) {
        // return the lightly modified bounds
        return bounds;
        // if it's a numerically indexed array, assume it's a
        // d3-selected rect and try to extract the positions
      } else if (
    // first try to make sure it's an array using Array.isArray
    typeof Array.isArray === 'function' && Array.isArray(bounds) ||
    // but since Array.isArray isn't always supported, fall
    // back to casting to the object to string when it's not
    Object.prototype.toString.call(bounds) === '[object Array]') {
      // once you're sure it's an array, extract the boundaries
      // from the rect
      var extractedBounds = extractBounds(bounds);
      return extractedBounds;
    } else {
      // but if the bounds are neither an object nor a numerical
      // array, then the bounds argument is invalid and you'll
      // need to fix it
      return false;
    }
  };

  var applyPadding = function applyPadding(bounds, padding) {
    var paddedBounds = bounds;
    if (padding !== 0) {
      paddedBounds.x = parseInt(paddedBounds.x) + padding;
      paddedBounds.y = parseInt(paddedBounds.y) + padding;
      paddedBounds.width -= padding * 2;
      paddedBounds.height -= padding * 2;
    }
    return paddedBounds;
  };

  // verify bounds
  var verifiedBounds = verifyBounds(bounds);

  // modify bounds if a padding value is provided
  if (padding) {
    verifiedBounds = applyPadding(verifiedBounds, padding);
  }

  // check that we have the necessary conditions for this function to operate properly
  if (
  // selection it's operating on cannot be not empty
  selection.length === 0 ||
  // d3 must be available
  !_d2.default ||
  // desired wrapping bounds must be provided as an input argument
  !bounds ||
  // input bounds must validate
  !verifiedBounds) {
    // try to return the calling selection if possible
    // so as not to interfere with methods downstream in the
    // chain
    if (selection) {
      return selection;
      // if all else fails, just return false. if you hit this point then you're
      // almost certainly trying to call the textwrap() method on something that
      // doesn't make sense!
    } else {
      return false;
    }
    // if we've validated everything then we can finally proceed
    // to the meat of this operation
  } else {
    // reassign the verified bounds as the set we want
    // to work with from here on; this ensures that we're
    // using the same data structure for our bounds regardless
    // of whether the input argument was a simple object or
    // a d3 selection
    bounds = verifiedBounds;

    // wrap using html and foreignObjects if they are supported
    var wrapWithForeignobjects = function wrapWithForeignobjects(item) {
      // establish variables to quickly reference target nodes later
      var parent = _d2.default.select(item[0].parentNode);
      var textNode = parent.select('text');
      var styledLineHeight = textNode.style('line-height');
      // extract our desired content from the single text element
      var textToWrap = textNode.text();
      // remove the text node and replace with a foreign object
      textNode.remove();
      var foreignObject = parent.append('foreignObject');
      // add foreign object and set dimensions, position, etc
      foreignObject.attr('requiredFeatures', 'http://www.w3.org/TR/SVG11/feature#Extensibility').attr('x', bounds.x).attr('y', bounds.y).attr('width', bounds.width).attr('height', bounds.height);
      // insert an HTML div
      var wrapDiv = foreignObject.append('xhtml:div')
      // this class is currently hardcoded
      // probably not necessary but easy to
      // override using .classed() and for now
      // it's nice to avoid a litany of input
      // arguments
      .attr('class', 'wrapped');
      // set div to same dimensions as foreign object
      wrapDiv.style('height', bounds.height).style('width', bounds.width)
      // insert text content
      .html(textToWrap);
      if (styledLineHeight) {
        wrapDiv.style('line-height', styledLineHeight);
      }
      returnValue = parent.select('foreignObject');
    };

    // wrap with tspans if foreignObject is undefined
    var wrapWithTspans = function wrapWithTspans(item) {
      // operate on the first text item in the selection
      var textNode = item[0];
      var parent = textNode.parentNode;
      var textNodeSelected = _d2.default.select(textNode);
      // measure initial size of the text node as rendered
      var textNodeHeight = textNode.getBBox().height;
      var textNodeWidth = textNode.getBBox().width;
      // figure out the line height, either from rendered height
      // of the font or attached styling
      var lineHeight;
      var renderedLineHeight = textNodeHeight;
      var styledLineHeight = textNodeSelected.style('line-height');
      if (styledLineHeight && parseInt(styledLineHeight)) {
        lineHeight = parseInt(styledLineHeight.replace('px', ''));
      } else {
        lineHeight = renderedLineHeight;
      }
      // only fire the rest of this if the text content
      // overflows the desired dimensions
      if (textNodeWidth > bounds.width) {
        // store whatever is inside the text node
        // in a variable and then zero out the
        // initial content; we'll reinsert in a moment
        // using tspan elements.
        var textToWrap = textNodeSelected.text();
        textNodeSelected.text('');
        if (textToWrap) {
          // keep track of whether we are splitting by spaces
          // so we know whether to reinsert those spaces later
          var breakDelimiter;
          // split at spaces to create an array of individual words
          var textToWrapArray;
          if (textToWrap.indexOf(' ') !== -1) {
            breakDelimiter = ' ';
            textToWrapArray = textToWrap.split(' ');
          } else {
            // if there are no spaces, figure out the split
            // points by comparing rendered text width against
            // bounds and translating that into character position
            // cuts
            breakDelimiter = '';
            var stringLength = textToWrap.length;
            var numberOfSubstrings = Math.ceil(textNodeWidth / bounds.width);
            var spliceInterval = Math.floor(stringLength / numberOfSubstrings);
            if (!(spliceInterval * numberOfSubstrings >= stringLength)) {
              numberOfSubstrings++;
            }
            textToWrapArray = [];
            var substring;
            var startPosition;
            for (var i = 0; i < numberOfSubstrings; i++) {
              startPosition = i * spliceInterval;
              substring = textToWrap.substr(startPosition, spliceInterval);
              textToWrapArray.push(substring);
            }
          }

          // new array where we'll store the words re-assembled into
          // substrings that have been tested against the desired
          // maximum wrapping width
          var substrings = [];
          // computed text length is arguably incorrectly reported for
          // all tspans after the first one, in that they will include
          // the width of previous separate tspans. to compensate we need
          // to manually track the computed text length of all those
          // previous tspans and substrings, and then use that to offset
          // the miscalculation. this then gives us the actual correct
          // position we want to use in rendering the text in the SVG.
          var totalOffset = 0;
          // object for storing the results of text length computations later
          var temp = {};
          // loop through the words and test the computed text length
          // of the string against the maximum desired wrapping width
          for (i = 0; i < textToWrapArray.length; i++) {
            var word = textToWrapArray[i];
            var previousString = textNodeSelected.text();
            var previousWidth = textNode.getComputedTextLength();
            // initialize the current word as the first word
            // or append to the previous string if one exists
            var newstring;
            if (previousString) {
              newstring = previousString + breakDelimiter + word;
            } else {
              newstring = word;
            }
            // add the newest substring back to the text node and
            // measure the length
            textNodeSelected.text(newstring);
            var newWidth = textNode.getComputedTextLength();
            // adjust the length by the offset we've tracked
            // due to the misreported length discussed above

            // if our latest version of the string is too
            // big for the bounds, use the previous
            // version of the string (without the newest word
            // added) and use the latest word to restart the
            // process with a new tspan
            if (newWidth > bounds.width) {
              if (previousString && previousString !== '') {
                totalOffset = totalOffset + previousWidth;
                temp = { string: previousString, width: previousWidth, offset: totalOffset };
                substrings.push(temp);
                textNodeSelected.text('');
                textNodeSelected.text(word);
                // Handle case where there is just one more word to be wrapped
                if (i === textToWrapArray.length - 1) {
                  newstring = word;
                  textNodeSelected.text(newstring);
                  newWidth = textNode.getComputedTextLength();
                }
              }
            }
            // if we're up to the last word in the array,
            // get the computed length as is without
            // appending anything further to it
            if (i === textToWrapArray.length - 1) {
              textNodeSelected.text('');
              var finalString = newstring;
              if (finalString && finalString !== '') {
                if (newWidth - totalOffset > 0) {
                  newWidth = newWidth - totalOffset;
                }
                temp = { string: finalString, width: newWidth, offset: totalOffset };
                substrings.push(temp);
              }
            }
          }

          // append each substring as a tspan
          var currentTspan;
          // var tspanCount
          // double check that the text content has been removed
          // before we start appending tspans
          textNodeSelected.text('');
          for (i = 0; i < substrings.length; i++) {
            substring = substrings[i].string;
            // only append if we're sure it won't make the tspans
            // overflow the bounds.
            if (i * lineHeight < bounds.height - lineHeight * 1.5) {
              currentTspan = textNodeSelected.append('tspan').text(substring);
              // vertical shift to all tspans after the first one
              currentTspan.attr('dy', function (d) {
                if (i > 0) {
                  return lineHeight;
                }
              });
              // shift left from default position, which
              // is probably based on the full length of the
              // text string until we make this adjustment
              currentTspan.attr('x', function () {
                var xOffset = bounds.x;
                if (padding) {
                  xOffset += padding;
                }
                return xOffset;
              });
            }
          }
        }
      }
      // position the overall text node, whether wrapped or not
      textNodeSelected.attr('y', function () {
        var yOffset = bounds.y;
        // shift by line-height to move the baseline into
        // the bounds – otherwise the text baseline would be
        // at the top of the bounds
        if (lineHeight) {
          yOffset += lineHeight;
        }
        // shift by padding, if it's there
        if (padding) {
          yOffset += padding;
        }
        return yOffset;
      });
      // shift to the right by the padding value
      textNodeSelected.attr('x', function () {
        var xOffset = bounds.x;
        if (padding) {
          xOffset += padding;
        }
        return xOffset;
      });

      // assign our modified text node with tspans
      // to the return value
      returnValue = _d2.default.select(parent).selectAll('text');
    };

    // variable used to hold the functions that let us
    // switch between the wrap methods
    var wrapMethod;

    // if a wrap method if being forced, assign that
    // function
    if (forceWrapMethod) {
      if (forceWrapMethod === 'foreignobjects') {
        wrapMethod = wrapWithForeignobjects;
      } else if (forceWrapMethod === 'tspans') {
        wrapMethod = wrapWithTspans;
      }
    }

    // if no wrap method is being forced, then instead
    // test for browser support of foreignobject and
    // use whichever wrap method makes sense accordingly
    if (!forceWrapMethod) {
      if (typeof SVGForeignObjectElement !== 'undefined') {
        wrapMethod = wrapWithForeignobjects;
      } else {
        wrapMethod = wrapWithTspans;
      }
    }

    // run the desired wrap function for each item
    // in the d3 selection that called .textwrap()
    for (var i = 0; i < selection.length; i++) {
      var item = selection[i];
      wrapMethod(item);
    }

    // return the modified nodes so we can chain other
    // methods to them.
    return returnValue;
  }
};

})();

exports.default = _d2.default;

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

// shim for using process in browser var process = module.exports = {};

// cached from whatever global is present so that test runners that stub it // don't break things. But we need to wrap it in a try catch in case it is // wrapped in strict mode code which doesn't define any globals. It's inside a // function because try/catches deoptimize in certain engines.

var cachedSetTimeout; var cachedClearTimeout;

function defaultSetTimout() {

throw new Error('setTimeout has not been defined');

} function defaultClearTimeout () {

throw new Error('clearTimeout has not been defined');

} (function () {

try {
    if (typeof setTimeout === 'function') {
        cachedSetTimeout = setTimeout;
    } else {
        cachedSetTimeout = defaultSetTimout;
    }
} catch (e) {
    cachedSetTimeout = defaultSetTimout;
}
try {
    if (typeof clearTimeout === 'function') {
        cachedClearTimeout = clearTimeout;
    } else {
        cachedClearTimeout = defaultClearTimeout;
    }
} catch (e) {
    cachedClearTimeout = defaultClearTimeout;
}

} ()) function runTimeout(fun) {

if (cachedSetTimeout === setTimeout) {
    //normal enviroments in sane situations
    return setTimeout(fun, 0);
}
// if setTimeout wasn't available but was latter defined
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
    cachedSetTimeout = setTimeout;
    return setTimeout(fun, 0);
}
try {
    // when when somebody has screwed with setTimeout but no I.E. maddness
    return cachedSetTimeout(fun, 0);
} catch(e){
    try {
        // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
        return cachedSetTimeout.call(null, fun, 0);
    } catch(e){
        // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
        return cachedSetTimeout.call(this, fun, 0);
    }
}

} function runClearTimeout(marker) {

if (cachedClearTimeout === clearTimeout) {
    //normal enviroments in sane situations
    return clearTimeout(marker);
}
// if clearTimeout wasn't available but was latter defined
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
    cachedClearTimeout = clearTimeout;
    return clearTimeout(marker);
}
try {
    // when when somebody has screwed with setTimeout but no I.E. maddness
    return cachedClearTimeout(marker);
} catch (e){
    try {
        // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
        return cachedClearTimeout.call(null, marker);
    } catch (e){
        // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
        // Some versions of I.E. have different rules for clearTimeout vs setTimeout
        return cachedClearTimeout.call(this, marker);
    }
}

} var queue = []; var draining = false; var currentQueue; var queueIndex = -1;

function cleanUpNextTick() {

if (!draining || !currentQueue) {
    return;
}
draining = false;
if (currentQueue.length) {
    queue = currentQueue.concat(queue);
} else {
    queueIndex = -1;
}
if (queue.length) {
    drainQueue();
}

}

function drainQueue() {

if (draining) {
    return;
}
var timeout = runTimeout(cleanUpNextTick);
draining = true;

var len = queue.length;
while(len) {
    currentQueue = queue;
    queue = [];
    while (++queueIndex < len) {
        if (currentQueue) {
            currentQueue[queueIndex].run();
        }
    }
    queueIndex = -1;
    len = queue.length;
}
currentQueue = null;
draining = false;
runClearTimeout(timeout);

}

process.nextTick = function (fun) {

var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
    for (var i = 1; i < arguments.length; i++) {
        args[i - 1] = arguments[i];
    }
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
    runTimeout(drainQueue);
}

};

// v8 likes predictible objects function Item(fun, array) {

this.fun = fun;
this.array = array;

} Item.prototype.run = function () {

this.fun.apply(null, this.array);

}; process.title = 'browser'; process.browser = true; process.env = {}; process.argv = []; process.version = ''; // empty string to avoid regexp issues process.versions = {};

function noop() {}

process.on = noop; process.addListener = noop; process.once = noop; process.off = noop; process.removeListener = noop; process.removeAllListeners = noop; process.emit = noop; process.prependListener = noop; process.prependOnceListener = noop;

process.listeners = function (name) { return [] }

process.binding = function (name) {

throw new Error('process.binding is not supported');

};

process.cwd = function () { return '/' }; process.chdir = function (dir) {

throw new Error('process.chdir is not supported');

}; process.umask = function() { return 0; };

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

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

/* WEBPACK VAR INJECTION */(function(process) {// Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the // “Software”), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE.

// resolves . and .. elements in a path array with directory names there // must be no slashes, empty elements, or device names (c:) in the array // (so also no leading and trailing slashes - it does not distinguish // relative and absolute paths) function normalizeArray(parts, allowAboveRoot) {

// if the path tries to go above the root, `up` ends up > 0
var up = 0;
for (var i = parts.length - 1; i >= 0; i--) {
  var last = parts[i];
  if (last === '.') {
    parts.splice(i, 1);
  } else if (last === '..') {
    parts.splice(i, 1);
    up++;
  } else if (up) {
    parts.splice(i, 1);
    up--;
  }
}

// if the path is allowed to go above the root, restore leading ..s
if (allowAboveRoot) {
  for (; up--; up) {
    parts.unshift('..');
  }
}

return parts;

}

// Split a filename into [root, dir, basename, ext], unix version // 'root' is just a slash, or nothing. var splitPathRe =

/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;

var splitPath = function(filename) {

return splitPathRe.exec(filename).slice(1);

};

// path.resolve([from …], to) // posix version exports.resolve = function() {

var resolvedPath = '',
    resolvedAbsolute = false;

for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
  var path = (i >= 0) ? arguments[i] : process.cwd();

  // Skip empty and invalid entries
  if (typeof path !== 'string') {
    throw new TypeError('Arguments to path.resolve must be strings');
  } else if (!path) {
    continue;
  }

  resolvedPath = path + '/' + resolvedPath;
  resolvedAbsolute = path.charAt(0) === '/';
}

// At this point the path should be resolved to a full absolute path, but
// handle relative paths to be safe (might happen when process.cwd() fails)

// Normalize the path
resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
  return !!p;
}), !resolvedAbsolute).join('/');

return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';

};

// path.normalize(path) // posix version exports.normalize = function(path) {

var isAbsolute = exports.isAbsolute(path),
    trailingSlash = substr(path, -1) === '/';

// Normalize the path
path = normalizeArray(filter(path.split('/'), function(p) {
  return !!p;
}), !isAbsolute).join('/');

if (!path && !isAbsolute) {
  path = '.';
}
if (path && trailingSlash) {
  path += '/';
}

return (isAbsolute ? '/' : '') + path;

};

// posix version exports.isAbsolute = function(path) {

return path.charAt(0) === '/';

};

// posix version exports.join = function() {

var paths = Array.prototype.slice.call(arguments, 0);
return exports.normalize(filter(paths, function(p, index) {
  if (typeof p !== 'string') {
    throw new TypeError('Arguments to path.join must be strings');
  }
  return p;
}).join('/'));

};

// path.relative(from, to) // posix version exports.relative = function(from, to) {

from = exports.resolve(from).substr(1);
to = exports.resolve(to).substr(1);

function trim(arr) {
  var start = 0;
  for (; start < arr.length; start++) {
    if (arr[start] !== '') break;
  }

  var end = arr.length - 1;
  for (; end >= 0; end--) {
    if (arr[end] !== '') break;
  }

  if (start > end) return [];
  return arr.slice(start, end - start + 1);
}

var fromParts = trim(from.split('/'));
var toParts = trim(to.split('/'));

var length = Math.min(fromParts.length, toParts.length);
var samePartsLength = length;
for (var i = 0; i < length; i++) {
  if (fromParts[i] !== toParts[i]) {
    samePartsLength = i;
    break;
  }
}

var outputParts = [];
for (var i = samePartsLength; i < fromParts.length; i++) {
  outputParts.push('..');
}

outputParts = outputParts.concat(toParts.slice(samePartsLength));

return outputParts.join('/');

};

exports.sep = '/'; exports.delimiter = ':';

exports.dirname = function(path) {

var result = splitPath(path),
    root = result[0],
    dir = result[1];

if (!root && !dir) {
  // No dirname whatsoever
  return '.';
}

if (dir) {
  // It has a dirname, strip trailing slash
  dir = dir.substr(0, dir.length - 1);
}

return root + dir;

};

exports.basename = function(path, ext) {

var f = splitPath(path)[2];
// TODO: make this comparison case-insensitive on windows?
if (ext && f.substr(-1 * ext.length) === ext) {
  f = f.substr(0, f.length - ext.length);
}
return f;

};

exports.extname = function(path) {

return splitPath(path)[3];

};

function filter (xs, f) {

if (xs.filter) return xs.filter(f);
var res = [];
for (var i = 0; i < xs.length; i++) {
    if (f(xs[i], i, xs)) res.push(xs[i]);
}
return res;

}

// String.prototype.substr - negative index don't work in IE8 var substr = 'ab'.substr(-1) === 'b'

? function (str, start, len) { return str.substr(start, len) }
: function (str, start, len) {
    if (start < 0) start = str.length + start;
    return str.substr(start, len);
}

;

/* WEBPACK VAR INJECTION */}.call(exports, webpack_require(7)))

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

var baseIsNative = webpack_require(244),

getValue = __webpack_require__(247);

/**

* Gets the native function at `key` of `object`.
*
* @private
* @param {Object} object The object to query.
* @param {string} key The key of the method to get.
* @returns {*} Returns the function if it's native, else `undefined`.
*/

function getNative(object, key) {

var value = getValue(object, key);
return baseIsNative(value) ? value : undefined;

}

module.exports = getNative;

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

var Symbol = webpack_require(22),

getRawTag = __webpack_require__(230),
objectToString = __webpack_require__(231);

/** `Object#toString` result references. */ var nullTag = '[object Null]',

undefinedTag = '[object Undefined]';

/** Built-in value references. */ var symToStringTag = Symbol ? Symbol.toStringTag : undefined;

/**

* The base implementation of `getTag` without fallbacks for buggy environments.
*
* @private
* @param {*} value The value to query.
* @returns {string} Returns the `toStringTag`.
*/

function baseGetTag(value) {

if (value == null) {
  return value === undefined ? undefinedTag : nullTag;
}
return (symToStringTag && symToStringTag in Object(value))
  ? getRawTag(value)
  : objectToString(value);

}

module.exports = baseGetTag;

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

/**

* Checks if `value` is object-like. A value is object-like if it's not `null`
* and has a `typeof` result of "object".
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
* @example
*
* _.isObjectLike({});
* // => true
*
* _.isObjectLike([1, 2, 3]);
* // => true
*
* _.isObjectLike(_.noop);
* // => false
*
* _.isObjectLike(null);
* // => false
*/

function isObjectLike(value) {

return value != null && typeof value == 'object';

}

module.exports = isObjectLike;

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

var isFunction = webpack_require(181),

isLength = __webpack_require__(33);

/**

* Checks if `value` is array-like. A value is considered array-like if it's
* not a function and has a `value.length` that's an integer greater than or
* equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is array-like, else `false`.
* @example
*
* _.isArrayLike([1, 2, 3]);
* // => true
*
* _.isArrayLike(document.body.children);
* // => true
*
* _.isArrayLike('abc');
* // => true
*
* _.isArrayLike(_.noop);
* // => false
*/

function isArrayLike(value) {

return value != null && isLength(value.length) && !isFunction(value);

}

module.exports = isArrayLike;

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

/**

* Checks if `value` is the
* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
* @example
*
* _.isObject({});
* // => true
*
* _.isObject([1, 2, 3]);
* // => true
*
* _.isObject(_.noop);
* // => true
*
* _.isObject(null);
* // => false
*/

function isObject(value) {

var type = typeof value;
return value != null && (type == 'object' || type == 'function');

}

module.exports = isObject;

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

var baseMatches = webpack_require(262),

baseMatchesProperty = __webpack_require__(305),
identity = __webpack_require__(18),
isArray = __webpack_require__(2),
property = __webpack_require__(315);

/**

* The base implementation of `_.iteratee`.
*
* @private
* @param {*} [value=_.identity] The value to convert to an iteratee.
* @returns {Function} Returns the iteratee.
*/

function baseIteratee(value) {

// Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
// See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
if (typeof value == 'function') {
  return value;
}
if (value == null) {
  return identity;
}
if (typeof value == 'object') {
  return isArray(value)
    ? baseMatchesProperty(value[0], value[1])
    : baseMatches(value);
}
return property(value);

}

module.exports = baseIteratee;

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

var baseGetTag = webpack_require(11),

isObjectLike = __webpack_require__(12);

/** `Object#toString` result references. */ var symbolTag = '[object Symbol]';

/**

* Checks if `value` is classified as a `Symbol` primitive or object.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
* @example
*
* _.isSymbol(Symbol.iterator);
* // => true
*
* _.isSymbol('abc');
* // => false
*/

function isSymbol(value) {

return typeof value == 'symbol' ||
  (isObjectLike(value) && baseGetTag(value) == symbolTag);

}

module.exports = isSymbol;

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

/* WEBPACK VAR INJECTION */(function(global, module) {/**

* @license
* Lodash <https://lodash.com/>
* Copyright JS Foundation and other contributors <https://js.foundation/>
* 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
*/

;(function() {

/** Used as a safe reference for `undefined` in pre-ES5 environments. */
var undefined;

/** Used as the semantic version number. */
var VERSION = '4.17.4';

/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;

/** Error message constants. */
var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',
    FUNC_ERROR_TEXT = 'Expected a function';

/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';

/** Used as the maximum memoize cache size. */
var MAX_MEMOIZE_SIZE = 500;

/** Used as the internal argument placeholder. */
var PLACEHOLDER = '__lodash_placeholder__';

/** Used to compose bitmasks for cloning. */
var CLONE_DEEP_FLAG = 1,
    CLONE_FLAT_FLAG = 2,
    CLONE_SYMBOLS_FLAG = 4;

/** Used to compose bitmasks for value comparisons. */
var COMPARE_PARTIAL_FLAG = 1,
    COMPARE_UNORDERED_FLAG = 2;

/** Used to compose bitmasks for function metadata. */
var WRAP_BIND_FLAG = 1,
    WRAP_BIND_KEY_FLAG = 2,
    WRAP_CURRY_BOUND_FLAG = 4,
    WRAP_CURRY_FLAG = 8,
    WRAP_CURRY_RIGHT_FLAG = 16,
    WRAP_PARTIAL_FLAG = 32,
    WRAP_PARTIAL_RIGHT_FLAG = 64,
    WRAP_ARY_FLAG = 128,
    WRAP_REARG_FLAG = 256,
    WRAP_FLIP_FLAG = 512;

/** Used as default options for `_.truncate`. */
var DEFAULT_TRUNC_LENGTH = 30,
    DEFAULT_TRUNC_OMISSION = '...';

/** Used to detect hot functions by number of calls within a span of milliseconds. */
var HOT_COUNT = 800,
    HOT_SPAN = 16;

/** Used to indicate the type of lazy iteratees. */
var LAZY_FILTER_FLAG = 1,
    LAZY_MAP_FLAG = 2,
    LAZY_WHILE_FLAG = 3;

/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0,
    MAX_SAFE_INTEGER = 9007199254740991,
    MAX_INTEGER = 1.7976931348623157e+308,
    NAN = 0 / 0;

/** Used as references for the maximum length and index of an array. */
var MAX_ARRAY_LENGTH = 4294967295,
    MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,
    HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;

/** Used to associate wrap methods with their bit flags. */
var wrapFlags = [
  ['ary', WRAP_ARY_FLAG],
  ['bind', WRAP_BIND_FLAG],
  ['bindKey', WRAP_BIND_KEY_FLAG],
  ['curry', WRAP_CURRY_FLAG],
  ['curryRight', WRAP_CURRY_RIGHT_FLAG],
  ['flip', WRAP_FLIP_FLAG],
  ['partial', WRAP_PARTIAL_FLAG],
  ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
  ['rearg', WRAP_REARG_FLAG]
];

/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    asyncTag = '[object AsyncFunction]',
    boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    domExcTag = '[object DOMException]',
    errorTag = '[object Error]',
    funcTag = '[object Function]',
    genTag = '[object GeneratorFunction]',
    mapTag = '[object Map]',
    numberTag = '[object Number]',
    nullTag = '[object Null]',
    objectTag = '[object Object]',
    promiseTag = '[object Promise]',
    proxyTag = '[object Proxy]',
    regexpTag = '[object RegExp]',
    setTag = '[object Set]',
    stringTag = '[object String]',
    symbolTag = '[object Symbol]',
    undefinedTag = '[object Undefined]',
    weakMapTag = '[object WeakMap]',
    weakSetTag = '[object WeakSet]';

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 empty string literals in compiled template source. */
var reEmptyStringLeading = /\b__p \+= '';/g,
    reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
    reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;

/** Used to match HTML entities and HTML characters. */
var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,
    reUnescapedHtml = /[&<>"']/g,
    reHasEscapedHtml = RegExp(reEscapedHtml.source),
    reHasUnescapedHtml = RegExp(reUnescapedHtml.source);

/** Used to match template delimiters. */
var reEscape = /<%-([\s\S]+?)%>/g,
    reEvaluate = /<%([\s\S]+?)%>/g,
    reInterpolate = /<%=([\s\S]+?)%>/g;

/** Used to match property names within property paths. */
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
    reIsPlainProp = /^\w*$/,
    reLeadingDot = /^\./,
    rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;

/**
 * Used to match `RegExp`
 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
 */
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,
    reHasRegExpChar = RegExp(reRegExpChar.source);

/** Used to match leading and trailing whitespace. */
var reTrim = /^\s+|\s+$/g,
    reTrimStart = /^\s+/,
    reTrimEnd = /\s+$/;

/** Used to match wrap detail comments. */
var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
    reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,
    reSplitDetails = /,? & /;

/** Used to match words composed of alphanumeric characters. */
var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;

/** Used to match backslashes in property paths. */
var reEscapeChar = /\\(\\)?/g;

/**
 * Used to match
 * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).
 */
var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;

/** Used to match `RegExp` flags from their coerced string values. */
var reFlags = /\w*$/;

/** Used to detect bad signed hexadecimal string values. */
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;

/** Used to detect binary string values. */
var reIsBinary = /^0b[01]+$/i;

/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;

/** Used to detect octal string values. */
var reIsOctal = /^0o[0-7]+$/i;

/** Used to detect unsigned integer values. */
var reIsUint = /^(?:0|[1-9]\d*)$/;

/** Used to match Latin Unicode letters (excluding mathematical operators). */
var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;

/** Used to ensure capturing order of template delimiters. */
var reNoMatch = /($^)/;

/** Used to match unescaped characters in compiled string literals. */
var reUnescapedString = /['\n\r\u2028\u2029\\]/g;

/** Used to compose unicode character classes. */
var rsAstralRange = '\\ud800-\\udfff',
    rsComboMarksRange = '\\u0300-\\u036f',
    reComboHalfMarksRange = '\\ufe20-\\ufe2f',
    rsComboSymbolsRange = '\\u20d0-\\u20ff',
    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
    rsDingbatRange = '\\u2700-\\u27bf',
    rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
    rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
    rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
    rsPunctuationRange = '\\u2000-\\u206f',
    rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',
    rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
    rsVarRange = '\\ufe0e\\ufe0f',
    rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;

/** Used to compose unicode capture groups. */
var rsApos = "['\u2019]",
    rsAstral = '[' + rsAstralRange + ']',
    rsBreak = '[' + rsBreakRange + ']',
    rsCombo = '[' + rsComboRange + ']',
    rsDigits = '\\d+',
    rsDingbat = '[' + rsDingbatRange + ']',
    rsLower = '[' + rsLowerRange + ']',
    rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
    rsFitz = '\\ud83c[\\udffb-\\udfff]',
    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
    rsNonAstral = '[^' + rsAstralRange + ']',
    rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
    rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
    rsUpper = '[' + rsUpperRange + ']',
    rsZWJ = '\\u200d';

/** Used to compose unicode regexes. */
var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',
    rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',
    rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
    rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
    reOptMod = rsModifier + '?',
    rsOptVar = '[' + rsVarRange + ']?',
    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
    rsOrdLower = '\\d*(?:(?:1st|2nd|3rd|(?![123])\\dth)\\b)',
    rsOrdUpper = '\\d*(?:(?:1ST|2ND|3RD|(?![123])\\dTH)\\b)',
    rsSeq = rsOptVar + reOptMod + rsOptJoin,
    rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,
    rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';

/** Used to match apostrophes. */
var reApos = RegExp(rsApos, 'g');

/**
 * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
 * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
 */
var reComboMark = RegExp(rsCombo, 'g');

/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');

/** Used to match complex or compound words. */
var reUnicodeWord = RegExp([
  rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
  rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',
  rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
  rsUpper + '+' + rsOptContrUpper,
  rsOrdUpper,
  rsOrdLower,
  rsDigits,
  rsEmoji
].join('|'), 'g');

/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');

/** Used to detect strings that need a more robust regexp to match words. */
var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;

/** Used to assign default `context` object properties. */
var contextProps = [
  'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',
  'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',
  'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',
  'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',
  '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'
];

/** Used to make template sourceURLs easier to identify. */
var templateCounter = -1;

/** Used to identify `toStringTag` values of typed arrays. */
var typedArrayTags = {};
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
typedArrayTags[uint32Tag] = true;
typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
typedArrayTags[errorTag] = typedArrayTags[funcTag] =
typedArrayTags[mapTag] = typedArrayTags[numberTag] =
typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
typedArrayTags[setTag] = typedArrayTags[stringTag] =
typedArrayTags[weakMapTag] = false;

/** 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;

/** Used to map Latin Unicode letters to basic Latin letters. */
var deburredLetters = {
  // Latin-1 Supplement block.
  '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
  '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
  '\xc7': 'C',  '\xe7': 'c',
  '\xd0': 'D',  '\xf0': 'd',
  '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
  '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
  '\xcc': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
  '\xec': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',
  '\xd1': 'N',  '\xf1': 'n',
  '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
  '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
  '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
  '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
  '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',
  '\xc6': 'Ae', '\xe6': 'ae',
  '\xde': 'Th', '\xfe': 'th',
  '\xdf': 'ss',
  // Latin Extended-A block.
  '\u0100': 'A',  '\u0102': 'A', '\u0104': 'A',
  '\u0101': 'a',  '\u0103': 'a', '\u0105': 'a',
  '\u0106': 'C',  '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
  '\u0107': 'c',  '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
  '\u010e': 'D',  '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
  '\u0112': 'E',  '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
  '\u0113': 'e',  '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
  '\u011c': 'G',  '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
  '\u011d': 'g',  '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
  '\u0124': 'H',  '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
  '\u0128': 'I',  '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
  '\u0129': 'i',  '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
  '\u0134': 'J',  '\u0135': 'j',
  '\u0136': 'K',  '\u0137': 'k', '\u0138': 'k',
  '\u0139': 'L',  '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
  '\u013a': 'l',  '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
  '\u0143': 'N',  '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
  '\u0144': 'n',  '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
  '\u014c': 'O',  '\u014e': 'O', '\u0150': 'O',
  '\u014d': 'o',  '\u014f': 'o', '\u0151': 'o',
  '\u0154': 'R',  '\u0156': 'R', '\u0158': 'R',
  '\u0155': 'r',  '\u0157': 'r', '\u0159': 'r',
  '\u015a': 'S',  '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
  '\u015b': 's',  '\u015d': 's', '\u015f': 's', '\u0161': 's',
  '\u0162': 'T',  '\u0164': 'T', '\u0166': 'T',
  '\u0163': 't',  '\u0165': 't', '\u0167': 't',
  '\u0168': 'U',  '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
  '\u0169': 'u',  '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
  '\u0174': 'W',  '\u0175': 'w',
  '\u0176': 'Y',  '\u0177': 'y', '\u0178': 'Y',
  '\u0179': 'Z',  '\u017b': 'Z', '\u017d': 'Z',
  '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',
  '\u0132': 'IJ', '\u0133': 'ij',
  '\u0152': 'Oe', '\u0153': 'oe',
  '\u0149': "'n", '\u017f': 's'
};

/** Used to map characters to HTML entities. */
var htmlEscapes = {
  '&': '&amp;',
  '<': '&lt;',
  '>': '&gt;',
  '"': '&quot;',
  "'": '&#39;'
};

/** Used to map HTML entities to characters. */
var htmlUnescapes = {
  '&amp;': '&',
  '&lt;': '<',
  '&gt;': '>',
  '&quot;': '"',
  '&#39;': "'"
};

/** Used to escape characters for inclusion in compiled string literals. */
var stringEscapes = {
  '\\': '\\',
  "'": "'",
  '\n': 'n',
  '\r': 'r',
  '\u2028': 'u2028',
  '\u2029': 'u2029'
};

/** Built-in method references without a dependency on `root`. */
var freeParseFloat = parseFloat,
    freeParseInt = parseInt;

/** 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;

/** Detect free variable `process` from Node.js. */
var freeProcess = moduleExports && freeGlobal.process;

/** Used to access faster Node.js helpers. */
var nodeUtil = (function() {
  try {
    return freeProcess && freeProcess.binding && freeProcess.binding('util');
  } catch (e) {}
}());

/* Node.js helper references. */
var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,
    nodeIsDate = nodeUtil && nodeUtil.isDate,
    nodeIsMap = nodeUtil && nodeUtil.isMap,
    nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,
    nodeIsSet = nodeUtil && nodeUtil.isSet,
    nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;

/*--------------------------------------------------------------------------*/

/**
 * 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 faster alternative to `Function#apply`, this function invokes `func`
 * with the `this` binding of `thisArg` and the arguments of `args`.
 *
 * @private
 * @param {Function} func The function to invoke.
 * @param {*} thisArg The `this` binding of `func`.
 * @param {Array} args The arguments to invoke `func` with.
 * @returns {*} Returns the result of `func`.
 */
function apply(func, thisArg, args) {
  switch (args.length) {
    case 0: return func.call(thisArg);
    case 1: return func.call(thisArg, args[0]);
    case 2: return func.call(thisArg, args[0], args[1]);
    case 3: return func.call(thisArg, args[0], args[1], args[2]);
  }
  return func.apply(thisArg, args);
}

/**
 * A specialized version of `baseAggregator` for arrays.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} setter The function to set `accumulator` values.
 * @param {Function} iteratee The iteratee to transform keys.
 * @param {Object} accumulator The initial aggregated object.
 * @returns {Function} Returns `accumulator`.
 */
function arrayAggregator(array, setter, iteratee, accumulator) {
  var index = -1,
      length = array == null ? 0 : array.length;

  while (++index < length) {
    var value = array[index];
    setter(accumulator, value, iteratee(value), array);
  }
  return accumulator;
}

/**
 * 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 == null ? 0 : array.length;

  while (++index < length) {
    if (iteratee(array[index], index, array) === false) {
      break;
    }
  }
  return array;
}

/**
 * A specialized version of `_.forEachRight` 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 arrayEachRight(array, iteratee) {
  var length = array == null ? 0 : array.length;

  while (length--) {
    if (iteratee(array[length], length, array) === false) {
      break;
    }
  }
  return array;
}

/**
 * A specialized version of `_.every` for arrays without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {boolean} Returns `true` if all elements pass the predicate check,
 *  else `false`.
 */
function arrayEvery(array, predicate) {
  var index = -1,
      length = array == null ? 0 : array.length;

  while (++index < length) {
    if (!predicate(array[index], index, array)) {
      return false;
    }
  }
  return true;
}

/**
 * A specialized version of `_.filter` for arrays without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {Array} Returns the new filtered array.
 */
function arrayFilter(array, predicate) {
  var index = -1,
      length = array == null ? 0 : array.length,
      resIndex = 0,
      result = [];

  while (++index < length) {
    var value = array[index];
    if (predicate(value, index, array)) {
      result[resIndex++] = value;
    }
  }
  return result;
}

/**
 * A specialized version of `_.includes` for arrays without support for
 * specifying an index to search from.
 *
 * @private
 * @param {Array} [array] The array to inspect.
 * @param {*} target The value to search for.
 * @returns {boolean} Returns `true` if `target` is found, else `false`.
 */
function arrayIncludes(array, value) {
  var length = array == null ? 0 : array.length;
  return !!length && baseIndexOf(array, value, 0) > -1;
}

/**
 * This function is like `arrayIncludes` except that it accepts a comparator.
 *
 * @private
 * @param {Array} [array] The array to inspect.
 * @param {*} target The value to search for.
 * @param {Function} comparator The comparator invoked per element.
 * @returns {boolean} Returns `true` if `target` is found, else `false`.
 */
function arrayIncludesWith(array, value, comparator) {
  var index = -1,
      length = array == null ? 0 : array.length;

  while (++index < length) {
    if (comparator(value, array[index])) {
      return true;
    }
  }
  return false;
}

/**
 * A specialized version of `_.map` 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 the new mapped array.
 */
function arrayMap(array, iteratee) {
  var index = -1,
      length = array == null ? 0 : array.length,
      result = Array(length);

  while (++index < length) {
    result[index] = iteratee(array[index], index, array);
  }
  return result;
}

/**
 * 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 == null ? 0 : array.length;

  if (initAccum && length) {
    accumulator = array[++index];
  }
  while (++index < length) {
    accumulator = iteratee(accumulator, array[index], index, array);
  }
  return accumulator;
}

/**
 * A specialized version of `_.reduceRight` 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 last element of `array` as
 *  the initial value.
 * @returns {*} Returns the accumulated value.
 */
function arrayReduceRight(array, iteratee, accumulator, initAccum) {
  var length = array == null ? 0 : array.length;
  if (initAccum && length) {
    accumulator = array[--length];
  }
  while (length--) {
    accumulator = iteratee(accumulator, array[length], length, array);
  }
  return accumulator;
}

/**
 * A specialized version of `_.some` for arrays without support for iteratee
 * shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {boolean} Returns `true` if any element passes the predicate check,
 *  else `false`.
 */
function arraySome(array, predicate) {
  var index = -1,
      length = array == null ? 0 : array.length;

  while (++index < length) {
    if (predicate(array[index], index, array)) {
      return true;
    }
  }
  return false;
}

/**
 * Gets the size of an ASCII `string`.
 *
 * @private
 * @param {string} string The string inspect.
 * @returns {number} Returns the string size.
 */
var asciiSize = baseProperty('length');

/**
 * Converts an ASCII `string` to an array.
 *
 * @private
 * @param {string} string The string to convert.
 * @returns {Array} Returns the converted array.
 */
function asciiToArray(string) {
  return string.split('');
}

/**
 * Splits an ASCII `string` into an array of its words.
 *
 * @private
 * @param {string} The string to inspect.
 * @returns {Array} Returns the words of `string`.
 */
function asciiWords(string) {
  return string.match(reAsciiWord) || [];
}

/**
 * The base implementation of methods like `_.findKey` and `_.findLastKey`,
 * without support for iteratee shorthands, which iterates over `collection`
 * using `eachFunc`.
 *
 * @private
 * @param {Array|Object} collection The collection to inspect.
 * @param {Function} predicate The function invoked per iteration.
 * @param {Function} eachFunc The function to iterate over `collection`.
 * @returns {*} Returns the found element or its key, else `undefined`.
 */
function baseFindKey(collection, predicate, eachFunc) {
  var result;
  eachFunc(collection, function(value, key, collection) {
    if (predicate(value, key, collection)) {
      result = key;
      return false;
    }
  });
  return result;
}

/**
 * The base implementation of `_.findIndex` and `_.findLastIndex` without
 * support for iteratee shorthands.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {Function} predicate The function invoked per iteration.
 * @param {number} fromIndex The index to search from.
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function baseFindIndex(array, predicate, fromIndex, fromRight) {
  var length = array.length,
      index = fromIndex + (fromRight ? 1 : -1);

  while ((fromRight ? index-- : ++index < length)) {
    if (predicate(array[index], index, array)) {
      return index;
    }
  }
  return -1;
}

/**
 * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} value The value to search for.
 * @param {number} fromIndex The index to search from.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function baseIndexOf(array, value, fromIndex) {
  return value === value
    ? strictIndexOf(array, value, fromIndex)
    : baseFindIndex(array, baseIsNaN, fromIndex);
}

/**
 * This function is like `baseIndexOf` except that it accepts a comparator.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} value The value to search for.
 * @param {number} fromIndex The index to search from.
 * @param {Function} comparator The comparator invoked per element.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function baseIndexOfWith(array, value, fromIndex, comparator) {
  var index = fromIndex - 1,
      length = array.length;

  while (++index < length) {
    if (comparator(array[index], value)) {
      return index;
    }
  }
  return -1;
}

/**
 * The base implementation of `_.isNaN` without support for number objects.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
 */
function baseIsNaN(value) {
  return value !== value;
}

/**
 * The base implementation of `_.mean` and `_.meanBy` without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} array The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {number} Returns the mean.
 */
function baseMean(array, iteratee) {
  var length = array == null ? 0 : array.length;
  return length ? (baseSum(array, iteratee) / length) : NAN;
}

/**
 * The base implementation of `_.property` without support for deep paths.
 *
 * @private
 * @param {string} key The key of the property to get.
 * @returns {Function} Returns the new accessor function.
 */
function baseProperty(key) {
  return function(object) {
    return object == null ? undefined : object[key];
  };
}

/**
 * The base implementation of `_.propertyOf` without support for deep paths.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Function} Returns the new accessor function.
 */
function basePropertyOf(object) {
  return function(key) {
    return object == null ? undefined : object[key];
  };
}

/**
 * The base implementation of `_.reduce` and `_.reduceRight`, without support
 * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
 *
 * @private
 * @param {Array|Object} collection The collection to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @param {*} accumulator The initial value.
 * @param {boolean} initAccum Specify using the first or last element of
 *  `collection` as the initial value.
 * @param {Function} eachFunc The function to iterate over `collection`.
 * @returns {*} Returns the accumulated value.
 */
function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
  eachFunc(collection, function(value, index, collection) {
    accumulator = initAccum
      ? (initAccum = false, value)
      : iteratee(accumulator, value, index, collection);
  });
  return accumulator;
}

/**
 * The base implementation of `_.sortBy` which uses `comparer` to define the
 * sort order of `array` and replaces criteria objects with their corresponding
 * values.
 *
 * @private
 * @param {Array} array The array to sort.
 * @param {Function} comparer The function to define sort order.
 * @returns {Array} Returns `array`.
 */
function baseSortBy(array, comparer) {
  var length = array.length;

  array.sort(comparer);
  while (length--) {
    array[length] = array[length].value;
  }
  return array;
}

/**
 * The base implementation of `_.sum` and `_.sumBy` without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} array The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {number} Returns the sum.
 */
function baseSum(array, iteratee) {
  var result,
      index = -1,
      length = array.length;

  while (++index < length) {
    var current = iteratee(array[index]);
    if (current !== undefined) {
      result = result === undefined ? current : (result + current);
    }
  }
  return result;
}

/**
 * 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;
}

/**
 * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array
 * of key-value pairs for `object` corresponding to the property names of `props`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {Array} props The property names to get values for.
 * @returns {Object} Returns the key-value pairs.
 */
function baseToPairs(object, props) {
  return arrayMap(props, function(key) {
    return [key, object[key]];
  });
}

/**
 * The base implementation of `_.unary` without support for storing metadata.
 *
 * @private
 * @param {Function} func The function to cap arguments for.
 * @returns {Function} Returns the new capped function.
 */
function baseUnary(func) {
  return function(value) {
    return func(value);
  };
}

/**
 * The base implementation of `_.values` and `_.valuesIn` which creates an
 * array of `object` property values corresponding to the property names
 * of `props`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {Array} props The property names to get values for.
 * @returns {Object} Returns the array of property values.
 */
function baseValues(object, props) {
  return arrayMap(props, function(key) {
    return object[key];
  });
}

/**
 * Checks if a `cache` value for `key` exists.
 *
 * @private
 * @param {Object} cache The cache to query.
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function cacheHas(cache, key) {
  return cache.has(key);
}

/**
 * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol
 * that is not found in the character symbols.
 *
 * @private
 * @param {Array} strSymbols The string symbols to inspect.
 * @param {Array} chrSymbols The character symbols to find.
 * @returns {number} Returns the index of the first unmatched string symbol.
 */
function charsStartIndex(strSymbols, chrSymbols) {
  var index = -1,
      length = strSymbols.length;

  while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
  return index;
}

/**
 * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol
 * that is not found in the character symbols.
 *
 * @private
 * @param {Array} strSymbols The string symbols to inspect.
 * @param {Array} chrSymbols The character symbols to find.
 * @returns {number} Returns the index of the last unmatched string symbol.
 */
function charsEndIndex(strSymbols, chrSymbols) {
  var index = strSymbols.length;

  while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
  return index;
}

/**
 * Gets the number of `placeholder` occurrences in `array`.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} placeholder The placeholder to search for.
 * @returns {number} Returns the placeholder count.
 */
function countHolders(array, placeholder) {
  var length = array.length,
      result = 0;

  while (length--) {
    if (array[length] === placeholder) {
      ++result;
    }
  }
  return result;
}

/**
 * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
 * letters to basic Latin letters.
 *
 * @private
 * @param {string} letter The matched letter to deburr.
 * @returns {string} Returns the deburred letter.
 */
var deburrLetter = basePropertyOf(deburredLetters);

/**
 * Used by `_.escape` to convert characters to HTML entities.
 *
 * @private
 * @param {string} chr The matched character to escape.
 * @returns {string} Returns the escaped character.
 */
var escapeHtmlChar = basePropertyOf(htmlEscapes);

/**
 * Used by `_.template` to escape characters for inclusion in compiled string literals.
 *
 * @private
 * @param {string} chr The matched character to escape.
 * @returns {string} Returns the escaped character.
 */
function escapeStringChar(chr) {
  return '\\' + stringEscapes[chr];
}

/**
 * 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 `string` contains Unicode symbols.
 *
 * @private
 * @param {string} string The string to inspect.
 * @returns {boolean} Returns `true` if a symbol is found, else `false`.
 */
function hasUnicode(string) {
  return reHasUnicode.test(string);
}

/**
 * Checks if `string` contains a word composed of Unicode symbols.
 *
 * @private
 * @param {string} string The string to inspect.
 * @returns {boolean} Returns `true` if a word is found, else `false`.
 */
function hasUnicodeWord(string) {
  return reHasUnicodeWord.test(string);
}

/**
 * Converts `iterator` to an array.
 *
 * @private
 * @param {Object} iterator The iterator to convert.
 * @returns {Array} Returns the converted array.
 */
function iteratorToArray(iterator) {
  var data,
      result = [];

  while (!(data = iterator.next()).done) {
    result.push(data.value);
  }
  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));
  };
}

/**
 * Replaces all `placeholder` elements in `array` with an internal placeholder
 * and returns an array of their indexes.
 *
 * @private
 * @param {Array} array The array to modify.
 * @param {*} placeholder The placeholder to replace.
 * @returns {Array} Returns the new array of placeholder indexes.
 */
function replaceHolders(array, placeholder) {
  var index = -1,
      length = array.length,
      resIndex = 0,
      result = [];

  while (++index < length) {
    var value = array[index];
    if (value === placeholder || value === PLACEHOLDER) {
      array[index] = PLACEHOLDER;
      result[resIndex++] = index;
    }
  }
  return result;
}

/**
 * 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;
}

/**
 * Converts `set` to its value-value pairs.
 *
 * @private
 * @param {Object} set The set to convert.
 * @returns {Array} Returns the value-value pairs.
 */
function setToPairs(set) {
  var index = -1,
      result = Array(set.size);

  set.forEach(function(value) {
    result[++index] = [value, value];
  });
  return result;
}

/**
 * A specialized version of `_.indexOf` which performs strict equality
 * comparisons of values, i.e. `===`.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} value The value to search for.
 * @param {number} fromIndex The index to search from.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function strictIndexOf(array, value, fromIndex) {
  var index = fromIndex - 1,
      length = array.length;

  while (++index < length) {
    if (array[index] === value) {
      return index;
    }
  }
  return -1;
}

/**
 * A specialized version of `_.lastIndexOf` which performs strict equality
 * comparisons of values, i.e. `===`.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} value The value to search for.
 * @param {number} fromIndex The index to search from.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function strictLastIndexOf(array, value, fromIndex) {
  var index = fromIndex + 1;
  while (index--) {
    if (array[index] === value) {
      return index;
    }
  }
  return index;
}

/**
 * Gets the number of symbols in `string`.
 *
 * @private
 * @param {string} string The string to inspect.
 * @returns {number} Returns the string size.
 */
function stringSize(string) {
  return hasUnicode(string)
    ? unicodeSize(string)
    : asciiSize(string);
}

/**
 * Converts `string` to an array.
 *
 * @private
 * @param {string} string The string to convert.
 * @returns {Array} Returns the converted array.
 */
function stringToArray(string) {
  return hasUnicode(string)
    ? unicodeToArray(string)
    : asciiToArray(string);
}

/**
 * Used by `_.unescape` to convert HTML entities to characters.
 *
 * @private
 * @param {string} chr The matched character to unescape.
 * @returns {string} Returns the unescaped character.
 */
var unescapeHtmlChar = basePropertyOf(htmlUnescapes);

/**
 * Gets the size of a Unicode `string`.
 *
 * @private
 * @param {string} string The string inspect.
 * @returns {number} Returns the string size.
 */
function unicodeSize(string) {
  var result = reUnicode.lastIndex = 0;
  while (reUnicode.test(string)) {
    ++result;
  }
  return result;
}

/**
 * Converts a Unicode `string` to an array.
 *
 * @private
 * @param {string} string The string to convert.
 * @returns {Array} Returns the converted array.
 */
function unicodeToArray(string) {
  return string.match(reUnicode) || [];
}

/**
 * Splits a Unicode `string` into an array of its words.
 *
 * @private
 * @param {string} The string to inspect.
 * @returns {Array} Returns the words of `string`.
 */
function unicodeWords(string) {
  return string.match(reUnicodeWord) || [];
}

/*--------------------------------------------------------------------------*/

/**
 * Create a new pristine `lodash` function using the `context` object.
 *
 * @static
 * @memberOf _
 * @since 1.1.0
 * @category Util
 * @param {Object} [context=root] The context object.
 * @returns {Function} Returns a new `lodash` function.
 * @example
 *
 * _.mixin({ 'foo': _.constant('foo') });
 *
 * var lodash = _.runInContext();
 * lodash.mixin({ 'bar': lodash.constant('bar') });
 *
 * _.isFunction(_.foo);
 * // => true
 * _.isFunction(_.bar);
 * // => false
 *
 * lodash.isFunction(lodash.foo);
 * // => false
 * lodash.isFunction(lodash.bar);
 * // => true
 *
 * // Create a suped-up `defer` in Node.js.
 * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;
 */
var runInContext = (function runInContext(context) {
  context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));

  /** Built-in constructor references. */
  var Array = context.Array,
      Date = context.Date,
      Error = context.Error,
      Function = context.Function,
      Math = context.Math,
      Object = context.Object,
      RegExp = context.RegExp,
      String = context.String,
      TypeError = context.TypeError;

  /** 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 = context['__core-js_shared__'];

  /** 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 generate unique IDs. */
  var idCounter = 0;

  /** 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
   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
   * of values.
   */
  var nativeObjectToString = objectProto.toString;

  /** Used to infer the `Object` constructor. */
  var objectCtorString = funcToString.call(Object);

  /** Used to restore the original `_` reference in `_.noConflict`. */
  var oldDash = root._;

  /** 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 ? context.Buffer : undefined,
      Symbol = context.Symbol,
      Uint8Array = context.Uint8Array,
      allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,
      getPrototype = overArg(Object.getPrototypeOf, Object),
      objectCreate = Object.create,
      propertyIsEnumerable = objectProto.propertyIsEnumerable,
      splice = arrayProto.splice,
      spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined,
      symIterator = Symbol ? Symbol.iterator : undefined,
      symToStringTag = Symbol ? Symbol.toStringTag : undefined;

  var defineProperty = (function() {
    try {
      var func = getNative(Object, 'defineProperty');
      func({}, '', {});
      return func;
    } catch (e) {}
  }());

  /** Mocked built-ins. */
  var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,
      ctxNow = Date && Date.now !== root.Date.now && Date.now,
      ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;

  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeCeil = Math.ceil,
      nativeFloor = Math.floor,
      nativeGetSymbols = Object.getOwnPropertySymbols,
      nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
      nativeIsFinite = context.isFinite,
      nativeJoin = arrayProto.join,
      nativeKeys = overArg(Object.keys, Object),
      nativeMax = Math.max,
      nativeMin = Math.min,
      nativeNow = Date.now,
      nativeParseInt = context.parseInt,
      nativeRandom = Math.random,
      nativeReverse = arrayProto.reverse;

  /* Built-in method references that are verified to be native. */
  var DataView = getNative(context, 'DataView'),
      Map = getNative(context, 'Map'),
      Promise = getNative(context, 'Promise'),
      Set = getNative(context, 'Set'),
      WeakMap = getNative(context, 'WeakMap'),
      nativeCreate = getNative(Object, 'create');

  /** Used to store function metadata. */
  var metaMap = WeakMap && new WeakMap;

  /** Used to lookup unminified function names. */
  var realNames = {};

  /** 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,
      symbolToString = symbolProto ? symbolProto.toString : undefined;

  /*------------------------------------------------------------------------*/

  /**
   * Creates a `lodash` object which wraps `value` to enable implicit method
   * chain sequences. Methods that operate on and return arrays, collections,
   * and functions can be chained together. Methods that retrieve a single value
   * or may return a primitive value will automatically end the chain sequence
   * and return the unwrapped value. Otherwise, the value must be unwrapped
   * with `_#value`.
   *
   * Explicit chain sequences, which must be unwrapped with `_#value`, may be
   * enabled using `_.chain`.
   *
   * The execution of chained methods is lazy, that is, it's deferred until
   * `_#value` is implicitly or explicitly called.
   *
   * Lazy evaluation allows several methods to support shortcut fusion.
   * Shortcut fusion is an optimization to merge iteratee calls; this avoids
   * the creation of intermediate arrays and can greatly reduce the number of
   * iteratee executions. Sections of a chain sequence qualify for shortcut
   * fusion if the section is applied to an array and iteratees accept only
   * one argument. The heuristic for whether a section qualifies for shortcut
   * fusion is subject to change.
   *
   * Chaining is supported in custom builds as long as the `_#value` method is
   * directly or indirectly included in the build.
   *
   * In addition to lodash methods, wrappers have `Array` and `String` methods.
   *
   * The wrapper `Array` methods are:
   * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`
   *
   * The wrapper `String` methods are:
   * `replace` and `split`
   *
   * The wrapper methods that support shortcut fusion are:
   * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,
   * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,
   * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`
   *
   * The chainable wrapper methods are:
   * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,
   * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,
   * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,
   * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,
   * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,
   * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,
   * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,
   * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,
   * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,
   * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,
   * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,
   * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,
   * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,
   * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,
   * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,
   * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,
   * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,
   * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,
   * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,
   * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,
   * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,
   * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,
   * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,
   * `zipObject`, `zipObjectDeep`, and `zipWith`
   *
   * The wrapper methods that are **not** chainable by default are:
   * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,
   * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,
   * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,
   * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,
   * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,
   * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,
   * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,
   * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,
   * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,
   * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,
   * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,
   * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,
   * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,
   * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,
   * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,
   * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,
   * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,
   * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
   * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,
   * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,
   * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,
   * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,
   * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,
   * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,
   * `upperFirst`, `value`, and `words`
   *
   * @name _
   * @constructor
   * @category Seq
   * @param {*} value The value to wrap in a `lodash` instance.
   * @returns {Object} Returns the new `lodash` wrapper instance.
   * @example
   *
   * function square(n) {
   *   return n * n;
   * }
   *
   * var wrapped = _([1, 2, 3]);
   *
   * // Returns an unwrapped value.
   * wrapped.reduce(_.add);
   * // => 6
   *
   * // Returns a wrapped value.
   * var squares = wrapped.map(square);
   *
   * _.isArray(squares);
   * // => false
   *
   * _.isArray(squares.value());
   * // => true
   */
  function lodash(value) {
    if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
      if (value instanceof LodashWrapper) {
        return value;
      }
      if (hasOwnProperty.call(value, '__wrapped__')) {
        return wrapperClone(value);
      }
    }
    return new LodashWrapper(value);
  }

  /**
   * The base implementation of `_.create` without support for assigning
   * properties to the created object.
   *
   * @private
   * @param {Object} proto The object to inherit from.
   * @returns {Object} Returns the new object.
   */
  var baseCreate = (function() {
    function object() {}
    return function(proto) {
      if (!isObject(proto)) {
        return {};
      }
      if (objectCreate) {
        return objectCreate(proto);
      }
      object.prototype = proto;
      var result = new object;
      object.prototype = undefined;
      return result;
    };
  }());

  /**
   * The function whose prototype chain sequence wrappers inherit from.
   *
   * @private
   */
  function baseLodash() {
    // No operation performed.
  }

  /**
   * The base constructor for creating `lodash` wrapper objects.
   *
   * @private
   * @param {*} value The value to wrap.
   * @param {boolean} [chainAll] Enable explicit method chain sequences.
   */
  function LodashWrapper(value, chainAll) {
    this.__wrapped__ = value;
    this.__actions__ = [];
    this.__chain__ = !!chainAll;
    this.__index__ = 0;
    this.__values__ = undefined;
  }

  /**
   * By default, the template delimiters used by lodash are like those in
   * embedded Ruby (ERB) as well as ES2015 template strings. Change the
   * following template settings to use alternative delimiters.
   *
   * @static
   * @memberOf _
   * @type {Object}
   */
  lodash.templateSettings = {

    /**
     * Used to detect `data` property values to be HTML-escaped.
     *
     * @memberOf _.templateSettings
     * @type {RegExp}
     */
    'escape': reEscape,

    /**
     * Used to detect code to be evaluated.
     *
     * @memberOf _.templateSettings
     * @type {RegExp}
     */
    'evaluate': reEvaluate,

    /**
     * Used to detect `data` property values to inject.
     *
     * @memberOf _.templateSettings
     * @type {RegExp}
     */
    'interpolate': reInterpolate,

    /**
     * Used to reference the data object in the template text.
     *
     * @memberOf _.templateSettings
     * @type {string}
     */
    'variable': '',

    /**
     * Used to import variables into the compiled template.
     *
     * @memberOf _.templateSettings
     * @type {Object}
     */
    'imports': {

      /**
       * A reference to the `lodash` function.
       *
       * @memberOf _.templateSettings.imports
       * @type {Function}
       */
      '_': lodash
    }
  };

  // Ensure wrappers are instances of `baseLodash`.
  lodash.prototype = baseLodash.prototype;
  lodash.prototype.constructor = lodash;

  LodashWrapper.prototype = baseCreate(baseLodash.prototype);
  LodashWrapper.prototype.constructor = LodashWrapper;

  /*------------------------------------------------------------------------*/

  /**
   * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
   *
   * @private
   * @constructor
   * @param {*} value The value to wrap.
   */
  function LazyWrapper(value) {
    this.__wrapped__ = value;
    this.__actions__ = [];
    this.__dir__ = 1;
    this.__filtered__ = false;
    this.__iteratees__ = [];
    this.__takeCount__ = MAX_ARRAY_LENGTH;
    this.__views__ = [];
  }

  /**
   * Creates a clone of the lazy wrapper object.
   *
   * @private
   * @name clone
   * @memberOf LazyWrapper
   * @returns {Object} Returns the cloned `LazyWrapper` object.
   */
  function lazyClone() {
    var result = new LazyWrapper(this.__wrapped__);
    result.__actions__ = copyArray(this.__actions__);
    result.__dir__ = this.__dir__;
    result.__filtered__ = this.__filtered__;
    result.__iteratees__ = copyArray(this.__iteratees__);
    result.__takeCount__ = this.__takeCount__;
    result.__views__ = copyArray(this.__views__);
    return result;
  }

  /**
   * Reverses the direction of lazy iteration.
   *
   * @private
   * @name reverse
   * @memberOf LazyWrapper
   * @returns {Object} Returns the new reversed `LazyWrapper` object.
   */
  function lazyReverse() {
    if (this.__filtered__) {
      var result = new LazyWrapper(this);
      result.__dir__ = -1;
      result.__filtered__ = true;
    } else {
      result = this.clone();
      result.__dir__ *= -1;
    }
    return result;
  }

  /**
   * Extracts the unwrapped value from its lazy wrapper.
   *
   * @private
   * @name value
   * @memberOf LazyWrapper
   * @returns {*} Returns the unwrapped value.
   */
  function lazyValue() {
    var array = this.__wrapped__.value(),
        dir = this.__dir__,
        isArr = isArray(array),
        isRight = dir < 0,
        arrLength = isArr ? array.length : 0,
        view = getView(0, arrLength, this.__views__),
        start = view.start,
        end = view.end,
        length = end - start,
        index = isRight ? end : (start - 1),
        iteratees = this.__iteratees__,
        iterLength = iteratees.length,
        resIndex = 0,
        takeCount = nativeMin(length, this.__takeCount__);

    if (!isArr || (!isRight && arrLength == length && takeCount == length)) {
      return baseWrapperValue(array, this.__actions__);
    }
    var result = [];

    outer:
    while (length-- && resIndex < takeCount) {
      index += dir;

      var iterIndex = -1,
          value = array[index];

      while (++iterIndex < iterLength) {
        var data = iteratees[iterIndex],
            iteratee = data.iteratee,
            type = data.type,
            computed = iteratee(value);

        if (type == LAZY_MAP_FLAG) {
          value = computed;
        } else if (!computed) {
          if (type == LAZY_FILTER_FLAG) {
            continue outer;
          } else {
            break outer;
          }
        }
      }
      result[resIndex++] = value;
    }
    return result;
  }

  // Ensure `LazyWrapper` is an instance of `baseLodash`.
  LazyWrapper.prototype = baseCreate(baseLodash.prototype);
  LazyWrapper.prototype.constructor = LazyWrapper;

  /*------------------------------------------------------------------------*/

  /**
   * Creates a hash object.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function Hash(entries) {
    var index = -1,
        length = entries == null ? 0 : entries.length;

    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) : {};
    this.size = 0;
  }

  /**
   * 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) {
    var result = this.has(key) && delete this.__data__[key];
    this.size -= result ? 1 : 0;
    return result;
  }

  /**
   * 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;
  }

  /**
   * Checks if a hash value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf Hash
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function hashHas(key) {
    var data = this.__data__;
    return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
  }

  /**
   * Sets the hash `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf Hash
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the hash instance.
   */
  function hashSet(key, value) {
    var data = this.__data__;
    this.size += this.has(key) ? 0 : 1;
    data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
    return this;
  }

  // Add methods to `Hash`.
  Hash.prototype.clear = hashClear;
  Hash.prototype['delete'] = hashDelete;
  Hash.prototype.get = hashGet;
  Hash.prototype.has = hashHas;
  Hash.prototype.set = hashSet;

  /*------------------------------------------------------------------------*/

  /**
   * Creates an list cache object.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function ListCache(entries) {
    var index = -1,
        length = entries == null ? 0 : entries.length;

    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }

  /**
   * Removes all key-value entries from the list cache.
   *
   * @private
   * @name clear
   * @memberOf ListCache
   */
  function listCacheClear() {
    this.__data__ = [];
    this.size = 0;
  }

  /**
   * Removes `key` and its value from the list cache.
   *
   * @private
   * @name delete
   * @memberOf ListCache
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function listCacheDelete(key) {
    var data = this.__data__,
        index = assocIndexOf(data, key);

    if (index < 0) {
      return false;
    }
    var lastIndex = data.length - 1;
    if (index == lastIndex) {
      data.pop();
    } else {
      splice.call(data, index, 1);
    }
    --this.size;
    return true;
  }

  /**
   * Gets the list cache value for `key`.
   *
   * @private
   * @name get
   * @memberOf ListCache
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function listCacheGet(key) {
    var data = this.__data__,
        index = assocIndexOf(data, key);

    return index < 0 ? undefined : data[index][1];
  }

  /**
   * Checks if a list cache value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf ListCache
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function listCacheHas(key) {
    return assocIndexOf(this.__data__, key) > -1;
  }

  /**
   * Sets the list cache `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf ListCache
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the list cache instance.
   */
  function listCacheSet(key, value) {
    var data = this.__data__,
        index = assocIndexOf(data, key);

    if (index < 0) {
      ++this.size;
      data.push([key, value]);
    } else {
      data[index][1] = value;
    }
    return this;
  }

  // Add methods to `ListCache`.
  ListCache.prototype.clear = listCacheClear;
  ListCache.prototype['delete'] = listCacheDelete;
  ListCache.prototype.get = listCacheGet;
  ListCache.prototype.has = listCacheHas;
  ListCache.prototype.set = listCacheSet;

  /*------------------------------------------------------------------------*/

  /**
   * Creates a map cache object to store key-value pairs.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function MapCache(entries) {
    var index = -1,
        length = entries == null ? 0 : entries.length;

    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }

  /**
   * Removes all key-value entries from the map.
   *
   * @private
   * @name clear
   * @memberOf MapCache
   */
  function mapCacheClear() {
    this.size = 0;
    this.__data__ = {
      'hash': new Hash,
      'map': new (Map || ListCache),
      'string': new Hash
    };
  }

  /**
   * Removes `key` and its value from the map.
   *
   * @private
   * @name delete
   * @memberOf MapCache
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function mapCacheDelete(key) {
    var result = getMapData(this, key)['delete'](key);
    this.size -= result ? 1 : 0;
    return result;
  }

  /**
   * Gets the map value for `key`.
   *
   * @private
   * @name get
   * @memberOf MapCache
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function mapCacheGet(key) {
    return getMapData(this, key).get(key);
  }

  /**
   * Checks if a map value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf MapCache
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function mapCacheHas(key) {
    return getMapData(this, key).has(key);
  }

  /**
   * Sets the map `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf MapCache
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the map cache instance.
   */
  function mapCacheSet(key, value) {
    var data = getMapData(this, key),
        size = data.size;

    data.set(key, value);
    this.size += data.size == size ? 0 : 1;
    return this;
  }

  // Add methods to `MapCache`.
  MapCache.prototype.clear = mapCacheClear;
  MapCache.prototype['delete'] = mapCacheDelete;
  MapCache.prototype.get = mapCacheGet;
  MapCache.prototype.has = mapCacheHas;
  MapCache.prototype.set = mapCacheSet;

  /*------------------------------------------------------------------------*/

  /**
   *
   * Creates an array cache object to store unique values.
   *
   * @private
   * @constructor
   * @param {Array} [values] The values to cache.
   */
  function SetCache(values) {
    var index = -1,
        length = values == null ? 0 : values.length;

    this.__data__ = new MapCache;
    while (++index < length) {
      this.add(values[index]);
    }
  }

  /**
   * Adds `value` to the array cache.
   *
   * @private
   * @name add
   * @memberOf SetCache
   * @alias push
   * @param {*} value The value to cache.
   * @returns {Object} Returns the cache instance.
   */
  function setCacheAdd(value) {
    this.__data__.set(value, HASH_UNDEFINED);
    return this;
  }

  /**
   * Checks if `value` is in the array cache.
   *
   * @private
   * @name has
   * @memberOf SetCache
   * @param {*} value The value to search for.
   * @returns {number} Returns `true` if `value` is found, else `false`.
   */
  function setCacheHas(value) {
    return this.__data__.has(value);
  }

  // Add methods to `SetCache`.
  SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
  SetCache.prototype.has = setCacheHas;

  /*------------------------------------------------------------------------*/

  /**
   * Creates a stack cache object to store key-value pairs.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function Stack(entries) {
    var data = this.__data__ = new ListCache(entries);
    this.size = data.size;
  }

  /**
   * Removes all key-value entries from the stack.
   *
   * @private
   * @name clear
   * @memberOf Stack
   */
  function stackClear() {
    this.__data__ = new ListCache;
    this.size = 0;
  }

  /**
   * Removes `key` and its value from the stack.
   *
   * @private
   * @name delete
   * @memberOf Stack
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function stackDelete(key) {
    var data = this.__data__,
        result = data['delete'](key);

    this.size = data.size;
    return result;
  }

  /**
   * Gets the stack value for `key`.
   *
   * @private
   * @name get
   * @memberOf Stack
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function stackGet(key) {
    return this.__data__.get(key);
  }

  /**
   * Checks if a stack value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf Stack
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function stackHas(key) {
    return this.__data__.has(key);
  }

  /**
   * Sets the stack `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf Stack
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the stack cache instance.
   */
  function stackSet(key, value) {
    var data = this.__data__;
    if (data instanceof ListCache) {
      var pairs = data.__data__;
      if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
        pairs.push([key, value]);
        this.size = ++data.size;
        return this;
      }
      data = this.__data__ = new MapCache(pairs);
    }
    data.set(key, value);
    this.size = data.size;
    return this;
  }

  // Add methods to `Stack`.
  Stack.prototype.clear = stackClear;
  Stack.prototype['delete'] = stackDelete;
  Stack.prototype.get = stackGet;
  Stack.prototype.has = stackHas;
  Stack.prototype.set = stackSet;

  /*------------------------------------------------------------------------*/

  /**
   * Creates an array of the enumerable property names of the array-like `value`.
   *
   * @private
   * @param {*} value The value to query.
   * @param {boolean} inherited Specify returning inherited property names.
   * @returns {Array} Returns the array of property names.
   */
  function arrayLikeKeys(value, inherited) {
    var isArr = isArray(value),
        isArg = !isArr && isArguments(value),
        isBuff = !isArr && !isArg && isBuffer(value),
        isType = !isArr && !isArg && !isBuff && isTypedArray(value),
        skipIndexes = isArr || isArg || isBuff || isType,
        result = skipIndexes ? baseTimes(value.length, String) : [],
        length = result.length;

    for (var key in value) {
      if ((inherited || hasOwnProperty.call(value, key)) &&
          !(skipIndexes && (
             // Safari 9 has enumerable `arguments.length` in strict mode.
             key == 'length' ||
             // Node.js 0.10 has enumerable non-index properties on buffers.
             (isBuff && (key == 'offset' || key == 'parent')) ||
             // PhantomJS 2 has enumerable non-index properties on typed arrays.
             (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
             // Skip index properties.
             isIndex(key, length)
          ))) {
        result.push(key);
      }
    }
    return result;
  }

  /**
   * A specialized version of `_.sample` for arrays.
   *
   * @private
   * @param {Array} array The array to sample.
   * @returns {*} Returns the random element.
   */
  function arraySample(array) {
    var length = array.length;
    return length ? array[baseRandom(0, length - 1)] : undefined;
  }

  /**
   * A specialized version of `_.sampleSize` for arrays.
   *
   * @private
   * @param {Array} array The array to sample.
   * @param {number} n The number of elements to sample.
   * @returns {Array} Returns the random elements.
   */
  function arraySampleSize(array, n) {
    return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
  }

  /**
   * A specialized version of `_.shuffle` for arrays.
   *
   * @private
   * @param {Array} array The array to shuffle.
   * @returns {Array} Returns the new shuffled array.
   */
  function arrayShuffle(array) {
    return shuffleSelf(copyArray(array));
  }

  /**
   * This function is like `assignValue` except that it doesn't assign
   * `undefined` values.
   *
   * @private
   * @param {Object} object The object to modify.
   * @param {string} key The key of the property to assign.
   * @param {*} value The value to assign.
   */
  function assignMergeValue(object, key, value) {
    if ((value !== undefined && !eq(object[key], value)) ||
        (value === undefined && !(key in object))) {
      baseAssignValue(object, key, value);
    }
  }

  /**
   * Assigns `value` to `key` of `object` if the existing value is not equivalent
   * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * for equality comparisons.
   *
   * @private
   * @param {Object} object The object to modify.
   * @param {string} key The key of the property to assign.
   * @param {*} value The value to assign.
   */
  function assignValue(object, key, value) {
    var objValue = object[key];
    if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
        (value === undefined && !(key in object))) {
      baseAssignValue(object, key, value);
    }
  }

  /**
   * Gets the index at which the `key` is found in `array` of key-value pairs.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} key The key to search for.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function assocIndexOf(array, key) {
    var length = array.length;
    while (length--) {
      if (eq(array[length][0], key)) {
        return length;
      }
    }
    return -1;
  }

  /**
   * Aggregates elements of `collection` on `accumulator` with keys transformed
   * by `iteratee` and values set by `setter`.
   *
   * @private
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} setter The function to set `accumulator` values.
   * @param {Function} iteratee The iteratee to transform keys.
   * @param {Object} accumulator The initial aggregated object.
   * @returns {Function} Returns `accumulator`.
   */
  function baseAggregator(collection, setter, iteratee, accumulator) {
    baseEach(collection, function(value, key, collection) {
      setter(accumulator, value, iteratee(value), collection);
    });
    return accumulator;
  }

  /**
   * The base implementation of `_.assign` without support for multiple sources
   * or `customizer` functions.
   *
   * @private
   * @param {Object} object The destination object.
   * @param {Object} source The source object.
   * @returns {Object} Returns `object`.
   */
  function baseAssign(object, source) {
    return object && copyObject(source, keys(source), object);
  }

  /**
   * The base implementation of `_.assignIn` without support for multiple sources
   * or `customizer` functions.
   *
   * @private
   * @param {Object} object The destination object.
   * @param {Object} source The source object.
   * @returns {Object} Returns `object`.
   */
  function baseAssignIn(object, source) {
    return object && copyObject(source, keysIn(source), object);
  }

  /**
   * The base implementation of `assignValue` and `assignMergeValue` without
   * value checks.
   *
   * @private
   * @param {Object} object The object to modify.
   * @param {string} key The key of the property to assign.
   * @param {*} value The value to assign.
   */
  function baseAssignValue(object, key, value) {
    if (key == '__proto__' && defineProperty) {
      defineProperty(object, key, {
        'configurable': true,
        'enumerable': true,
        'value': value,
        'writable': true
      });
    } else {
      object[key] = value;
    }
  }

  /**
   * The base implementation of `_.at` without support for individual paths.
   *
   * @private
   * @param {Object} object The object to iterate over.
   * @param {string[]} paths The property paths to pick.
   * @returns {Array} Returns the picked elements.
   */
  function baseAt(object, paths) {
    var index = -1,
        length = paths.length,
        result = Array(length),
        skip = object == null;

    while (++index < length) {
      result[index] = skip ? undefined : get(object, paths[index]);
    }
    return result;
  }

  /**
   * The base implementation of `_.clamp` which doesn't coerce arguments.
   *
   * @private
   * @param {number} number The number to clamp.
   * @param {number} [lower] The lower bound.
   * @param {number} upper The upper bound.
   * @returns {number} Returns the clamped number.
   */
  function baseClamp(number, lower, upper) {
    if (number === number) {
      if (upper !== undefined) {
        number = number <= upper ? number : upper;
      }
      if (lower !== undefined) {
        number = number >= lower ? number : lower;
      }
    }
    return number;
  }

  /**
   * The base implementation of `_.clone` and `_.cloneDeep` which tracks
   * traversed objects.
   *
   * @private
   * @param {*} value The value to clone.
   * @param {boolean} bitmask The bitmask flags.
   *  1 - Deep clone
   *  2 - Flatten inherited properties
   *  4 - Clone symbols
   * @param {Function} [customizer] The function to customize cloning.
   * @param {string} [key] The key of `value`.
   * @param {Object} [object] The parent object of `value`.
   * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
   * @returns {*} Returns the cloned value.
   */
  function baseClone(value, bitmask, customizer, key, object, stack) {
    var result,
        isDeep = bitmask & CLONE_DEEP_FLAG,
        isFlat = bitmask & CLONE_FLAT_FLAG,
        isFull = bitmask & CLONE_SYMBOLS_FLAG;

    if (customizer) {
      result = object ? customizer(value, key, object, stack) : customizer(value);
    }
    if (result !== undefined) {
      return result;
    }
    if (!isObject(value)) {
      return value;
    }
    var isArr = isArray(value);
    if (isArr) {
      result = initCloneArray(value);
      if (!isDeep) {
        return copyArray(value, result);
      }
    } else {
      var tag = getTag(value),
          isFunc = tag == funcTag || tag == genTag;

      if (isBuffer(value)) {
        return cloneBuffer(value, isDeep);
      }
      if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
        result = (isFlat || isFunc) ? {} : initCloneObject(value);
        if (!isDeep) {
          return isFlat
            ? copySymbolsIn(value, baseAssignIn(result, value))
            : copySymbols(value, baseAssign(result, value));
        }
      } else {
        if (!cloneableTags[tag]) {
          return object ? value : {};
        }
        result = initCloneByTag(value, tag, baseClone, isDeep);
      }
    }
    // Check for circular references and return its corresponding clone.
    stack || (stack = new Stack);
    var stacked = stack.get(value);
    if (stacked) {
      return stacked;
    }
    stack.set(value, result);

    var keysFunc = isFull
      ? (isFlat ? getAllKeysIn : getAllKeys)
      : (isFlat ? keysIn : keys);

    var props = isArr ? undefined : keysFunc(value);
    arrayEach(props || value, function(subValue, key) {
      if (props) {
        key = subValue;
        subValue = value[key];
      }
      // Recursively populate clone (susceptible to call stack limits).
      assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
    });
    return result;
  }

  /**
   * The base implementation of `_.conforms` which doesn't clone `source`.
   *
   * @private
   * @param {Object} source The object of property predicates to conform to.
   * @returns {Function} Returns the new spec function.
   */
  function baseConforms(source) {
    var props = keys(source);
    return function(object) {
      return baseConformsTo(object, source, props);
    };
  }

  /**
   * The base implementation of `_.conformsTo` which accepts `props` to check.
   *
   * @private
   * @param {Object} object The object to inspect.
   * @param {Object} source The object of property predicates to conform to.
   * @returns {boolean} Returns `true` if `object` conforms, else `false`.
   */
  function baseConformsTo(object, source, props) {
    var length = props.length;
    if (object == null) {
      return !length;
    }
    object = Object(object);
    while (length--) {
      var key = props[length],
          predicate = source[key],
          value = object[key];

      if ((value === undefined && !(key in object)) || !predicate(value)) {
        return false;
      }
    }
    return true;
  }

  /**
   * The base implementation of `_.delay` and `_.defer` which accepts `args`
   * to provide to `func`.
   *
   * @private
   * @param {Function} func The function to delay.
   * @param {number} wait The number of milliseconds to delay invocation.
   * @param {Array} args The arguments to provide to `func`.
   * @returns {number|Object} Returns the timer id or timeout object.
   */
  function baseDelay(func, wait, args) {
    if (typeof func != 'function') {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    return setTimeout(function() { func.apply(undefined, args); }, wait);
  }

  /**
   * The base implementation of methods like `_.difference` without support
   * for excluding multiple arrays or iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {Array} values The values to exclude.
   * @param {Function} [iteratee] The iteratee invoked per element.
   * @param {Function} [comparator] The comparator invoked per element.
   * @returns {Array} Returns the new array of filtered values.
   */
  function baseDifference(array, values, iteratee, comparator) {
    var index = -1,
        includes = arrayIncludes,
        isCommon = true,
        length = array.length,
        result = [],
        valuesLength = values.length;

    if (!length) {
      return result;
    }
    if (iteratee) {
      values = arrayMap(values, baseUnary(iteratee));
    }
    if (comparator) {
      includes = arrayIncludesWith;
      isCommon = false;
    }
    else if (values.length >= LARGE_ARRAY_SIZE) {
      includes = cacheHas;
      isCommon = false;
      values = new SetCache(values);
    }
    outer:
    while (++index < length) {
      var value = array[index],
          computed = iteratee == null ? value : iteratee(value);

      value = (comparator || value !== 0) ? value : 0;
      if (isCommon && computed === computed) {
        var valuesIndex = valuesLength;
        while (valuesIndex--) {
          if (values[valuesIndex] === computed) {
            continue outer;
          }
        }
        result.push(value);
      }
      else if (!includes(values, computed, comparator)) {
        result.push(value);
      }
    }
    return result;
  }

  /**
   * The base implementation of `_.forEach` without support for iteratee shorthands.
   *
   * @private
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array|Object} Returns `collection`.
   */
  var baseEach = createBaseEach(baseForOwn);

  /**
   * The base implementation of `_.forEachRight` without support for iteratee shorthands.
   *
   * @private
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array|Object} Returns `collection`.
   */
  var baseEachRight = createBaseEach(baseForOwnRight, true);

  /**
   * The base implementation of `_.every` without support for iteratee shorthands.
   *
   * @private
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {boolean} Returns `true` if all elements pass the predicate check,
   *  else `false`
   */
  function baseEvery(collection, predicate) {
    var result = true;
    baseEach(collection, function(value, index, collection) {
      result = !!predicate(value, index, collection);
      return result;
    });
    return result;
  }

  /**
   * The base implementation of methods like `_.max` and `_.min` which accepts a
   * `comparator` to determine the extremum value.
   *
   * @private
   * @param {Array} array The array to iterate over.
   * @param {Function} iteratee The iteratee invoked per iteration.
   * @param {Function} comparator The comparator used to compare values.
   * @returns {*} Returns the extremum value.
   */
  function baseExtremum(array, iteratee, comparator) {
    var index = -1,
        length = array.length;

    while (++index < length) {
      var value = array[index],
          current = iteratee(value);

      if (current != null && (computed === undefined
            ? (current === current && !isSymbol(current))
            : comparator(current, computed)
          )) {
        var computed = current,
            result = value;
      }
    }
    return result;
  }

  /**
   * The base implementation of `_.fill` without an iteratee call guard.
   *
   * @private
   * @param {Array} array The array to fill.
   * @param {*} value The value to fill `array` with.
   * @param {number} [start=0] The start position.
   * @param {number} [end=array.length] The end position.
   * @returns {Array} Returns `array`.
   */
  function baseFill(array, value, start, end) {
    var length = array.length;

    start = toInteger(start);
    if (start < 0) {
      start = -start > length ? 0 : (length + start);
    }
    end = (end === undefined || end > length) ? length : toInteger(end);
    if (end < 0) {
      end += length;
    }
    end = start > end ? 0 : toLength(end);
    while (start < end) {
      array[start++] = value;
    }
    return array;
  }

  /**
   * The base implementation of `_.filter` without support for iteratee shorthands.
   *
   * @private
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {Array} Returns the new filtered array.
   */
  function baseFilter(collection, predicate) {
    var result = [];
    baseEach(collection, function(value, index, collection) {
      if (predicate(value, index, collection)) {
        result.push(value);
      }
    });
    return result;
  }

  /**
   * The base implementation of `_.flatten` with support for restricting flattening.
   *
   * @private
   * @param {Array} array The array to flatten.
   * @param {number} depth The maximum recursion depth.
   * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
   * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
   * @param {Array} [result=[]] The initial result value.
   * @returns {Array} Returns the new flattened array.
   */
  function baseFlatten(array, depth, predicate, isStrict, result) {
    var index = -1,
        length = array.length;

    predicate || (predicate = isFlattenable);
    result || (result = []);

    while (++index < length) {
      var value = array[index];
      if (depth > 0 && predicate(value)) {
        if (depth > 1) {
          // Recursively flatten arrays (susceptible to call stack limits).
          baseFlatten(value, depth - 1, predicate, isStrict, result);
        } else {
          arrayPush(result, value);
        }
      } else if (!isStrict) {
        result[result.length] = value;
      }
    }
    return result;
  }

  /**
   * The base implementation of `baseForOwn` which iterates over `object`
   * properties returned by `keysFunc` and invokes `iteratee` for each property.
   * Iteratee functions may exit iteration early by explicitly returning `false`.
   *
   * @private
   * @param {Object} object The object to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @param {Function} keysFunc The function to get the keys of `object`.
   * @returns {Object} Returns `object`.
   */
  var baseFor = createBaseFor();

  /**
   * This function is like `baseFor` except that it iterates over properties
   * in the opposite order.
   *
   * @private
   * @param {Object} object The object to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @param {Function} keysFunc The function to get the keys of `object`.
   * @returns {Object} Returns `object`.
   */
  var baseForRight = createBaseFor(true);

  /**
   * The base implementation of `_.forOwn` without support for iteratee shorthands.
   *
   * @private
   * @param {Object} object The object to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Object} Returns `object`.
   */
  function baseForOwn(object, iteratee) {
    return object && baseFor(object, iteratee, keys);
  }

  /**
   * The base implementation of `_.forOwnRight` without support for iteratee shorthands.
   *
   * @private
   * @param {Object} object The object to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Object} Returns `object`.
   */
  function baseForOwnRight(object, iteratee) {
    return object && baseForRight(object, iteratee, keys);
  }

  /**
   * The base implementation of `_.functions` which creates an array of
   * `object` function property names filtered from `props`.
   *
   * @private
   * @param {Object} object The object to inspect.
   * @param {Array} props The property names to filter.
   * @returns {Array} Returns the function names.
   */
  function baseFunctions(object, props) {
    return arrayFilter(props, function(key) {
      return isFunction(object[key]);
    });
  }

  /**
   * The base implementation of `_.get` without support for default values.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Array|string} path The path of the property to get.
   * @returns {*} Returns the resolved value.
   */
  function baseGet(object, path) {
    path = castPath(path, object);

    var index = 0,
        length = path.length;

    while (object != null && index < length) {
      object = object[toKey(path[index++])];
    }
    return (index && index == length) ? object : undefined;
  }

  /**
   * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
   * `keysFunc` and `symbolsFunc` to get the enumerable property names and
   * symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Function} keysFunc The function to get the keys of `object`.
   * @param {Function} symbolsFunc The function to get the symbols of `object`.
   * @returns {Array} Returns the array of property names and symbols.
   */
  function baseGetAllKeys(object, keysFunc, symbolsFunc) {
    var result = keysFunc(object);
    return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
  }

  /**
   * The base implementation of `getTag` without fallbacks for buggy environments.
   *
   * @private
   * @param {*} value The value to query.
   * @returns {string} Returns the `toStringTag`.
   */
  function baseGetTag(value) {
    if (value == null) {
      return value === undefined ? undefinedTag : nullTag;
    }
    return (symToStringTag && symToStringTag in Object(value))
      ? getRawTag(value)
      : objectToString(value);
  }

  /**
   * The base implementation of `_.gt` which doesn't coerce arguments.
   *
   * @private
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {boolean} Returns `true` if `value` is greater than `other`,
   *  else `false`.
   */
  function baseGt(value, other) {
    return value > other;
  }

  /**
   * The base implementation of `_.has` without support for deep paths.
   *
   * @private
   * @param {Object} [object] The object to query.
   * @param {Array|string} key The key to check.
   * @returns {boolean} Returns `true` if `key` exists, else `false`.
   */
  function baseHas(object, key) {
    return object != null && hasOwnProperty.call(object, key);
  }

  /**
   * The base implementation of `_.hasIn` without support for deep paths.
   *
   * @private
   * @param {Object} [object] The object to query.
   * @param {Array|string} key The key to check.
   * @returns {boolean} Returns `true` if `key` exists, else `false`.
   */
  function baseHasIn(object, key) {
    return object != null && key in Object(object);
  }

  /**
   * The base implementation of `_.inRange` which doesn't coerce arguments.
   *
   * @private
   * @param {number} number The number to check.
   * @param {number} start The start of the range.
   * @param {number} end The end of the range.
   * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
   */
  function baseInRange(number, start, end) {
    return number >= nativeMin(start, end) && number < nativeMax(start, end);
  }

  /**
   * The base implementation of methods like `_.intersection`, without support
   * for iteratee shorthands, that accepts an array of arrays to inspect.
   *
   * @private
   * @param {Array} arrays The arrays to inspect.
   * @param {Function} [iteratee] The iteratee invoked per element.
   * @param {Function} [comparator] The comparator invoked per element.
   * @returns {Array} Returns the new array of shared values.
   */
  function baseIntersection(arrays, iteratee, comparator) {
    var includes = comparator ? arrayIncludesWith : arrayIncludes,
        length = arrays[0].length,
        othLength = arrays.length,
        othIndex = othLength,
        caches = Array(othLength),
        maxLength = Infinity,
        result = [];

    while (othIndex--) {
      var array = arrays[othIndex];
      if (othIndex && iteratee) {
        array = arrayMap(array, baseUnary(iteratee));
      }
      maxLength = nativeMin(array.length, maxLength);
      caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
        ? new SetCache(othIndex && array)
        : undefined;
    }
    array = arrays[0];

    var index = -1,
        seen = caches[0];

    outer:
    while (++index < length && result.length < maxLength) {
      var value = array[index],
          computed = iteratee ? iteratee(value) : value;

      value = (comparator || value !== 0) ? value : 0;
      if (!(seen
            ? cacheHas(seen, computed)
            : includes(result, computed, comparator)
          )) {
        othIndex = othLength;
        while (--othIndex) {
          var cache = caches[othIndex];
          if (!(cache
                ? cacheHas(cache, computed)
                : includes(arrays[othIndex], computed, comparator))
              ) {
            continue outer;
          }
        }
        if (seen) {
          seen.push(computed);
        }
        result.push(value);
      }
    }
    return result;
  }

  /**
   * The base implementation of `_.invert` and `_.invertBy` which inverts
   * `object` with values transformed by `iteratee` and set by `setter`.
   *
   * @private
   * @param {Object} object The object to iterate over.
   * @param {Function} setter The function to set `accumulator` values.
   * @param {Function} iteratee The iteratee to transform values.
   * @param {Object} accumulator The initial inverted object.
   * @returns {Function} Returns `accumulator`.
   */
  function baseInverter(object, setter, iteratee, accumulator) {
    baseForOwn(object, function(value, key, object) {
      setter(accumulator, iteratee(value), key, object);
    });
    return accumulator;
  }

  /**
   * The base implementation of `_.invoke` without support for individual
   * method arguments.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Array|string} path The path of the method to invoke.
   * @param {Array} args The arguments to invoke the method with.
   * @returns {*} Returns the result of the invoked method.
   */
  function baseInvoke(object, path, args) {
    path = castPath(path, object);
    object = parent(object, path);
    var func = object == null ? object : object[toKey(last(path))];
    return func == null ? undefined : apply(func, object, args);
  }

  /**
   * The base implementation of `_.isArguments`.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an `arguments` object,
   */
  function baseIsArguments(value) {
    return isObjectLike(value) && baseGetTag(value) == argsTag;
  }

  /**
   * The base implementation of `_.isArrayBuffer` without Node.js optimizations.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
   */
  function baseIsArrayBuffer(value) {
    return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
  }

  /**
   * The base implementation of `_.isDate` without Node.js optimizations.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
   */
  function baseIsDate(value) {
    return isObjectLike(value) && baseGetTag(value) == dateTag;
  }

  /**
   * The base implementation of `_.isEqual` which supports partial comparisons
   * and tracks traversed objects.
   *
   * @private
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @param {boolean} bitmask The bitmask flags.
   *  1 - Unordered comparison
   *  2 - Partial comparison
   * @param {Function} [customizer] The function to customize comparisons.
   * @param {Object} [stack] Tracks traversed `value` and `other` objects.
   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
   */
  function baseIsEqual(value, other, bitmask, customizer, stack) {
    if (value === other) {
      return true;
    }
    if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
      return value !== value && other !== other;
    }
    return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
  }

  /**
   * A specialized version of `baseIsEqual` for arrays and objects which performs
   * deep comparisons and tracks traversed objects enabling objects with circular
   * references to be compared.
   *
   * @private
   * @param {Object} object The object to compare.
   * @param {Object} other The other object to compare.
   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
   * @param {Function} customizer The function to customize comparisons.
   * @param {Function} equalFunc The function to determine equivalents of values.
   * @param {Object} [stack] Tracks traversed `object` and `other` objects.
   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
   */
  function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
    var objIsArr = isArray(object),
        othIsArr = isArray(other),
        objTag = objIsArr ? arrayTag : getTag(object),
        othTag = othIsArr ? arrayTag : getTag(other);

    objTag = objTag == argsTag ? objectTag : objTag;
    othTag = othTag == argsTag ? objectTag : othTag;

    var objIsObj = objTag == objectTag,
        othIsObj = othTag == objectTag,
        isSameTag = objTag == othTag;

    if (isSameTag && isBuffer(object)) {
      if (!isBuffer(other)) {
        return false;
      }
      objIsArr = true;
      objIsObj = false;
    }
    if (isSameTag && !objIsObj) {
      stack || (stack = new Stack);
      return (objIsArr || isTypedArray(object))
        ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
        : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
    }
    if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
      var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
          othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');

      if (objIsWrapped || othIsWrapped) {
        var objUnwrapped = objIsWrapped ? object.value() : object,
            othUnwrapped = othIsWrapped ? other.value() : other;

        stack || (stack = new Stack);
        return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
      }
    }
    if (!isSameTag) {
      return false;
    }
    stack || (stack = new Stack);
    return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
  }

  /**
   * The base implementation of `_.isMap` without Node.js optimizations.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a map, else `false`.
   */
  function baseIsMap(value) {
    return isObjectLike(value) && getTag(value) == mapTag;
  }

  /**
   * The base implementation of `_.isMatch` without support for iteratee shorthands.
   *
   * @private
   * @param {Object} object The object to inspect.
   * @param {Object} source The object of property values to match.
   * @param {Array} matchData The property names, values, and compare flags to match.
   * @param {Function} [customizer] The function to customize comparisons.
   * @returns {boolean} Returns `true` if `object` is a match, else `false`.
   */
  function baseIsMatch(object, source, matchData, customizer) {
    var index = matchData.length,
        length = index,
        noCustomizer = !customizer;

    if (object == null) {
      return !length;
    }
    object = Object(object);
    while (index--) {
      var data = matchData[index];
      if ((noCustomizer && data[2])
            ? data[1] !== object[data[0]]
            : !(data[0] in object)
          ) {
        return false;
      }
    }
    while (++index < length) {
      data = matchData[index];
      var key = data[0],
          objValue = object[key],
          srcValue = data[1];

      if (noCustomizer && data[2]) {
        if (objValue === undefined && !(key in object)) {
          return false;
        }
      } else {
        var stack = new Stack;
        if (customizer) {
          var result = customizer(objValue, srcValue, key, object, source, stack);
        }
        if (!(result === undefined
              ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
              : result
            )) {
          return false;
        }
      }
    }
    return true;
  }

  /**
   * The base implementation of `_.isNative` without bad shim checks.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a native function,
   *  else `false`.
   */
  function baseIsNative(value) {
    if (!isObject(value) || isMasked(value)) {
      return false;
    }
    var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
    return pattern.test(toSource(value));
  }

  /**
   * The base implementation of `_.isRegExp` without Node.js optimizations.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
   */
  function baseIsRegExp(value) {
    return isObjectLike(value) && baseGetTag(value) == regexpTag;
  }

  /**
   * The base implementation of `_.isSet` without Node.js optimizations.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a set, else `false`.
   */
  function baseIsSet(value) {
    return isObjectLike(value) && getTag(value) == setTag;
  }

  /**
   * The base implementation of `_.isTypedArray` without Node.js optimizations.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
   */
  function baseIsTypedArray(value) {
    return isObjectLike(value) &&
      isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
  }

  /**
   * The base implementation of `_.iteratee`.
   *
   * @private
   * @param {*} [value=_.identity] The value to convert to an iteratee.
   * @returns {Function} Returns the iteratee.
   */
  function baseIteratee(value) {
    // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
    // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
    if (typeof value == 'function') {
      return value;
    }
    if (value == null) {
      return identity;
    }
    if (typeof value == 'object') {
      return isArray(value)
        ? baseMatchesProperty(value[0], value[1])
        : baseMatches(value);
    }
    return property(value);
  }

  /**
   * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   */
  function baseKeys(object) {
    if (!isPrototype(object)) {
      return nativeKeys(object);
    }
    var result = [];
    for (var key in Object(object)) {
      if (hasOwnProperty.call(object, key) && key != 'constructor') {
        result.push(key);
      }
    }
    return result;
  }

  /**
   * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   */
  function baseKeysIn(object) {
    if (!isObject(object)) {
      return nativeKeysIn(object);
    }
    var isProto = isPrototype(object),
        result = [];

    for (var key in object) {
      if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
        result.push(key);
      }
    }
    return result;
  }

  /**
   * The base implementation of `_.lt` which doesn't coerce arguments.
   *
   * @private
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {boolean} Returns `true` if `value` is less than `other`,
   *  else `false`.
   */
  function baseLt(value, other) {
    return value < other;
  }

  /**
   * The base implementation of `_.map` without support for iteratee shorthands.
   *
   * @private
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array} Returns the new mapped array.
   */
  function baseMap(collection, iteratee) {
    var index = -1,
        result = isArrayLike(collection) ? Array(collection.length) : [];

    baseEach(collection, function(value, key, collection) {
      result[++index] = iteratee(value, key, collection);
    });
    return result;
  }

  /**
   * The base implementation of `_.matches` which doesn't clone `source`.
   *
   * @private
   * @param {Object} source The object of property values to match.
   * @returns {Function} Returns the new spec function.
   */
  function baseMatches(source) {
    var matchData = getMatchData(source);
    if (matchData.length == 1 && matchData[0][2]) {
      return matchesStrictComparable(matchData[0][0], matchData[0][1]);
    }
    return function(object) {
      return object === source || baseIsMatch(object, source, matchData);
    };
  }

  /**
   * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
   *
   * @private
   * @param {string} path The path of the property to get.
   * @param {*} srcValue The value to match.
   * @returns {Function} Returns the new spec function.
   */
  function baseMatchesProperty(path, srcValue) {
    if (isKey(path) && isStrictComparable(srcValue)) {
      return matchesStrictComparable(toKey(path), srcValue);
    }
    return function(object) {
      var objValue = get(object, path);
      return (objValue === undefined && objValue === srcValue)
        ? hasIn(object, path)
        : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
    };
  }

  /**
   * The base implementation of `_.merge` without support for multiple sources.
   *
   * @private
   * @param {Object} object The destination object.
   * @param {Object} source The source object.
   * @param {number} srcIndex The index of `source`.
   * @param {Function} [customizer] The function to customize merged values.
   * @param {Object} [stack] Tracks traversed source values and their merged
   *  counterparts.
   */
  function baseMerge(object, source, srcIndex, customizer, stack) {
    if (object === source) {
      return;
    }
    baseFor(source, function(srcValue, key) {
      if (isObject(srcValue)) {
        stack || (stack = new Stack);
        baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
      }
      else {
        var newValue = customizer
          ? customizer(object[key], srcValue, (key + ''), object, source, stack)
          : undefined;

        if (newValue === undefined) {
          newValue = srcValue;
        }
        assignMergeValue(object, key, newValue);
      }
    }, keysIn);
  }

  /**
   * A specialized version of `baseMerge` for arrays and objects which performs
   * deep merges and tracks traversed objects enabling objects with circular
   * references to be merged.
   *
   * @private
   * @param {Object} object The destination object.
   * @param {Object} source The source object.
   * @param {string} key The key of the value to merge.
   * @param {number} srcIndex The index of `source`.
   * @param {Function} mergeFunc The function to merge values.
   * @param {Function} [customizer] The function to customize assigned values.
   * @param {Object} [stack] Tracks traversed source values and their merged
   *  counterparts.
   */
  function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
    var objValue = object[key],
        srcValue = source[key],
        stacked = stack.get(srcValue);

    if (stacked) {
      assignMergeValue(object, key, stacked);
      return;
    }
    var newValue = customizer
      ? customizer(objValue, srcValue, (key + ''), object, source, stack)
      : undefined;

    var isCommon = newValue === undefined;

    if (isCommon) {
      var isArr = isArray(srcValue),
          isBuff = !isArr && isBuffer(srcValue),
          isTyped = !isArr && !isBuff && isTypedArray(srcValue);

      newValue = srcValue;
      if (isArr || isBuff || isTyped) {
        if (isArray(objValue)) {
          newValue = objValue;
        }
        else if (isArrayLikeObject(objValue)) {
          newValue = copyArray(objValue);
        }
        else if (isBuff) {
          isCommon = false;
          newValue = cloneBuffer(srcValue, true);
        }
        else if (isTyped) {
          isCommon = false;
          newValue = cloneTypedArray(srcValue, true);
        }
        else {
          newValue = [];
        }
      }
      else if (isPlainObject(srcValue) || isArguments(srcValue)) {
        newValue = objValue;
        if (isArguments(objValue)) {
          newValue = toPlainObject(objValue);
        }
        else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
          newValue = initCloneObject(srcValue);
        }
      }
      else {
        isCommon = false;
      }
    }
    if (isCommon) {
      // Recursively merge objects and arrays (susceptible to call stack limits).
      stack.set(srcValue, newValue);
      mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
      stack['delete'](srcValue);
    }
    assignMergeValue(object, key, newValue);
  }

  /**
   * The base implementation of `_.nth` which doesn't coerce arguments.
   *
   * @private
   * @param {Array} array The array to query.
   * @param {number} n The index of the element to return.
   * @returns {*} Returns the nth element of `array`.
   */
  function baseNth(array, n) {
    var length = array.length;
    if (!length) {
      return;
    }
    n += n < 0 ? length : 0;
    return isIndex(n, length) ? array[n] : undefined;
  }

  /**
   * The base implementation of `_.orderBy` without param guards.
   *
   * @private
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
   * @param {string[]} orders The sort orders of `iteratees`.
   * @returns {Array} Returns the new sorted array.
   */
  function baseOrderBy(collection, iteratees, orders) {
    var index = -1;
    iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(getIteratee()));

    var result = baseMap(collection, function(value, key, collection) {
      var criteria = arrayMap(iteratees, function(iteratee) {
        return iteratee(value);
      });
      return { 'criteria': criteria, 'index': ++index, 'value': value };
    });

    return baseSortBy(result, function(object, other) {
      return compareMultiple(object, other, orders);
    });
  }

  /**
   * The base implementation of `_.pick` without support for individual
   * property identifiers.
   *
   * @private
   * @param {Object} object The source object.
   * @param {string[]} paths The property paths to pick.
   * @returns {Object} Returns the new object.
   */
  function basePick(object, paths) {
    return basePickBy(object, paths, function(value, path) {
      return hasIn(object, path);
    });
  }

  /**
   * The base implementation of  `_.pickBy` without support for iteratee shorthands.
   *
   * @private
   * @param {Object} object The source object.
   * @param {string[]} paths The property paths to pick.
   * @param {Function} predicate The function invoked per property.
   * @returns {Object} Returns the new object.
   */
  function basePickBy(object, paths, predicate) {
    var index = -1,
        length = paths.length,
        result = {};

    while (++index < length) {
      var path = paths[index],
          value = baseGet(object, path);

      if (predicate(value, path)) {
        baseSet(result, castPath(path, object), value);
      }
    }
    return result;
  }

  /**
   * A specialized version of `baseProperty` which supports deep paths.
   *
   * @private
   * @param {Array|string} path The path of the property to get.
   * @returns {Function} Returns the new accessor function.
   */
  function basePropertyDeep(path) {
    return function(object) {
      return baseGet(object, path);
    };
  }

  /**
   * The base implementation of `_.pullAllBy` without support for iteratee
   * shorthands.
   *
   * @private
   * @param {Array} array The array to modify.
   * @param {Array} values The values to remove.
   * @param {Function} [iteratee] The iteratee invoked per element.
   * @param {Function} [comparator] The comparator invoked per element.
   * @returns {Array} Returns `array`.
   */
  function basePullAll(array, values, iteratee, comparator) {
    var indexOf = comparator ? baseIndexOfWith : baseIndexOf,
        index = -1,
        length = values.length,
        seen = array;

    if (array === values) {
      values = copyArray(values);
    }
    if (iteratee) {
      seen = arrayMap(array, baseUnary(iteratee));
    }
    while (++index < length) {
      var fromIndex = 0,
          value = values[index],
          computed = iteratee ? iteratee(value) : value;

      while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
        if (seen !== array) {
          splice.call(seen, fromIndex, 1);
        }
        splice.call(array, fromIndex, 1);
      }
    }
    return array;
  }

  /**
   * The base implementation of `_.pullAt` without support for individual
   * indexes or capturing the removed elements.
   *
   * @private
   * @param {Array} array The array to modify.
   * @param {number[]} indexes The indexes of elements to remove.
   * @returns {Array} Returns `array`.
   */
  function basePullAt(array, indexes) {
    var length = array ? indexes.length : 0,
        lastIndex = length - 1;

    while (length--) {
      var index = indexes[length];
      if (length == lastIndex || index !== previous) {
        var previous = index;
        if (isIndex(index)) {
          splice.call(array, index, 1);
        } else {
          baseUnset(array, index);
        }
      }
    }
    return array;
  }

  /**
   * The base implementation of `_.random` without support for returning
   * floating-point numbers.
   *
   * @private
   * @param {number} lower The lower bound.
   * @param {number} upper The upper bound.
   * @returns {number} Returns the random number.
   */
  function baseRandom(lower, upper) {
    return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
  }

  /**
   * The base implementation of `_.range` and `_.rangeRight` which doesn't
   * coerce arguments.
   *
   * @private
   * @param {number} start The start of the range.
   * @param {number} end The end of the range.
   * @param {number} step The value to increment or decrement by.
   * @param {boolean} [fromRight] Specify iterating from right to left.
   * @returns {Array} Returns the range of numbers.
   */
  function baseRange(start, end, step, fromRight) {
    var index = -1,
        length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
        result = Array(length);

    while (length--) {
      result[fromRight ? length : ++index] = start;
      start += step;
    }
    return result;
  }

  /**
   * The base implementation of `_.repeat` which doesn't coerce arguments.
   *
   * @private
   * @param {string} string The string to repeat.
   * @param {number} n The number of times to repeat the string.
   * @returns {string} Returns the repeated string.
   */
  function baseRepeat(string, n) {
    var result = '';
    if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
      return result;
    }
    // Leverage the exponentiation by squaring algorithm for a faster repeat.
    // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
    do {
      if (n % 2) {
        result += string;
      }
      n = nativeFloor(n / 2);
      if (n) {
        string += string;
      }
    } while (n);

    return result;
  }

  /**
   * The base implementation of `_.rest` which doesn't validate or coerce arguments.
   *
   * @private
   * @param {Function} func The function to apply a rest parameter to.
   * @param {number} [start=func.length-1] The start position of the rest parameter.
   * @returns {Function} Returns the new function.
   */
  function baseRest(func, start) {
    return setToString(overRest(func, start, identity), func + '');
  }

  /**
   * The base implementation of `_.sample`.
   *
   * @private
   * @param {Array|Object} collection The collection to sample.
   * @returns {*} Returns the random element.
   */
  function baseSample(collection) {
    return arraySample(values(collection));
  }

  /**
   * The base implementation of `_.sampleSize` without param guards.
   *
   * @private
   * @param {Array|Object} collection The collection to sample.
   * @param {number} n The number of elements to sample.
   * @returns {Array} Returns the random elements.
   */
  function baseSampleSize(collection, n) {
    var array = values(collection);
    return shuffleSelf(array, baseClamp(n, 0, array.length));
  }

  /**
   * The base implementation of `_.set`.
   *
   * @private
   * @param {Object} object The object to modify.
   * @param {Array|string} path The path of the property to set.
   * @param {*} value The value to set.
   * @param {Function} [customizer] The function to customize path creation.
   * @returns {Object} Returns `object`.
   */
  function baseSet(object, path, value, customizer) {
    if (!isObject(object)) {
      return object;
    }
    path = castPath(path, object);

    var index = -1,
        length = path.length,
        lastIndex = length - 1,
        nested = object;

    while (nested != null && ++index < length) {
      var key = toKey(path[index]),
          newValue = value;

      if (index != lastIndex) {
        var objValue = nested[key];
        newValue = customizer ? customizer(objValue, key, nested) : undefined;
        if (newValue === undefined) {
          newValue = isObject(objValue)
            ? objValue
            : (isIndex(path[index + 1]) ? [] : {});
        }
      }
      assignValue(nested, key, newValue);
      nested = nested[key];
    }
    return object;
  }

  /**
   * The base implementation of `setData` without support for hot loop shorting.
   *
   * @private
   * @param {Function} func The function to associate metadata with.
   * @param {*} data The metadata.
   * @returns {Function} Returns `func`.
   */
  var baseSetData = !metaMap ? identity : function(func, data) {
    metaMap.set(func, data);
    return func;
  };

  /**
   * The base implementation of `setToString` without support for hot loop shorting.
   *
   * @private
   * @param {Function} func The function to modify.
   * @param {Function} string The `toString` result.
   * @returns {Function} Returns `func`.
   */
  var baseSetToString = !defineProperty ? identity : function(func, string) {
    return defineProperty(func, 'toString', {
      'configurable': true,
      'enumerable': false,
      'value': constant(string),
      'writable': true
    });
  };

  /**
   * The base implementation of `_.shuffle`.
   *
   * @private
   * @param {Array|Object} collection The collection to shuffle.
   * @returns {Array} Returns the new shuffled array.
   */
  function baseShuffle(collection) {
    return shuffleSelf(values(collection));
  }

  /**
   * The base implementation of `_.slice` without an iteratee call guard.
   *
   * @private
   * @param {Array} array The array to slice.
   * @param {number} [start=0] The start position.
   * @param {number} [end=array.length] The end position.
   * @returns {Array} Returns the slice of `array`.
   */
  function baseSlice(array, start, end) {
    var index = -1,
        length = array.length;

    if (start < 0) {
      start = -start > length ? 0 : (length + start);
    }
    end = end > length ? length : end;
    if (end < 0) {
      end += length;
    }
    length = start > end ? 0 : ((end - start) >>> 0);
    start >>>= 0;

    var result = Array(length);
    while (++index < length) {
      result[index] = array[index + start];
    }
    return result;
  }

  /**
   * The base implementation of `_.some` without support for iteratee shorthands.
   *
   * @private
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {boolean} Returns `true` if any element passes the predicate check,
   *  else `false`.
   */
  function baseSome(collection, predicate) {
    var result;

    baseEach(collection, function(value, index, collection) {
      result = predicate(value, index, collection);
      return !result;
    });
    return !!result;
  }

  /**
   * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which
   * performs a binary search of `array` to determine the index at which `value`
   * should be inserted into `array` in order to maintain its sort order.
   *
   * @private
   * @param {Array} array The sorted array to inspect.
   * @param {*} value The value to evaluate.
   * @param {boolean} [retHighest] Specify returning the highest qualified index.
   * @returns {number} Returns the index at which `value` should be inserted
   *  into `array`.
   */
  function baseSortedIndex(array, value, retHighest) {
    var low = 0,
        high = array == null ? low : array.length;

    if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
      while (low < high) {
        var mid = (low + high) >>> 1,
            computed = array[mid];

        if (computed !== null && !isSymbol(computed) &&
            (retHighest ? (computed <= value) : (computed < value))) {
          low = mid + 1;
        } else {
          high = mid;
        }
      }
      return high;
    }
    return baseSortedIndexBy(array, value, identity, retHighest);
  }

  /**
   * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
   * which invokes `iteratee` for `value` and each element of `array` to compute
   * their sort ranking. The iteratee is invoked with one argument; (value).
   *
   * @private
   * @param {Array} array The sorted array to inspect.
   * @param {*} value The value to evaluate.
   * @param {Function} iteratee The iteratee invoked per element.
   * @param {boolean} [retHighest] Specify returning the highest qualified index.
   * @returns {number} Returns the index at which `value` should be inserted
   *  into `array`.
   */
  function baseSortedIndexBy(array, value, iteratee, retHighest) {
    value = iteratee(value);

    var low = 0,
        high = array == null ? 0 : array.length,
        valIsNaN = value !== value,
        valIsNull = value === null,
        valIsSymbol = isSymbol(value),
        valIsUndefined = value === undefined;

    while (low < high) {
      var mid = nativeFloor((low + high) / 2),
          computed = iteratee(array[mid]),
          othIsDefined = computed !== undefined,
          othIsNull = computed === null,
          othIsReflexive = computed === computed,
          othIsSymbol = isSymbol(computed);

      if (valIsNaN) {
        var setLow = retHighest || othIsReflexive;
      } else if (valIsUndefined) {
        setLow = othIsReflexive && (retHighest || othIsDefined);
      } else if (valIsNull) {
        setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
      } else if (valIsSymbol) {
        setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
      } else if (othIsNull || othIsSymbol) {
        setLow = false;
      } else {
        setLow = retHighest ? (computed <= value) : (computed < value);
      }
      if (setLow) {
        low = mid + 1;
      } else {
        high = mid;
      }
    }
    return nativeMin(high, MAX_ARRAY_INDEX);
  }

  /**
   * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without
   * support for iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {Function} [iteratee] The iteratee invoked per element.
   * @returns {Array} Returns the new duplicate free array.
   */
  function baseSortedUniq(array, iteratee) {
    var index = -1,
        length = array.length,
        resIndex = 0,
        result = [];

    while (++index < length) {
      var value = array[index],
          computed = iteratee ? iteratee(value) : value;

      if (!index || !eq(computed, seen)) {
        var seen = computed;
        result[resIndex++] = value === 0 ? 0 : value;
      }
    }
    return result;
  }

  /**
   * The base implementation of `_.toNumber` which doesn't ensure correct
   * conversions of binary, hexadecimal, or octal string values.
   *
   * @private
   * @param {*} value The value to process.
   * @returns {number} Returns the number.
   */
  function baseToNumber(value) {
    if (typeof value == 'number') {
      return value;
    }
    if (isSymbol(value)) {
      return NAN;
    }
    return +value;
  }

  /**
   * The base implementation of `_.toString` which doesn't convert nullish
   * values to empty strings.
   *
   * @private
   * @param {*} value The value to process.
   * @returns {string} Returns the string.
   */
  function baseToString(value) {
    // Exit early for strings to avoid a performance hit in some environments.
    if (typeof value == 'string') {
      return value;
    }
    if (isArray(value)) {
      // Recursively convert values (susceptible to call stack limits).
      return arrayMap(value, baseToString) + '';
    }
    if (isSymbol(value)) {
      return symbolToString ? symbolToString.call(value) : '';
    }
    var result = (value + '');
    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
  }

  /**
   * The base implementation of `_.uniqBy` without support for iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {Function} [iteratee] The iteratee invoked per element.
   * @param {Function} [comparator] The comparator invoked per element.
   * @returns {Array} Returns the new duplicate free array.
   */
  function baseUniq(array, iteratee, comparator) {
    var index = -1,
        includes = arrayIncludes,
        length = array.length,
        isCommon = true,
        result = [],
        seen = result;

    if (comparator) {
      isCommon = false;
      includes = arrayIncludesWith;
    }
    else if (length >= LARGE_ARRAY_SIZE) {
      var set = iteratee ? null : createSet(array);
      if (set) {
        return setToArray(set);
      }
      isCommon = false;
      includes = cacheHas;
      seen = new SetCache;
    }
    else {
      seen = iteratee ? [] : result;
    }
    outer:
    while (++index < length) {
      var value = array[index],
          computed = iteratee ? iteratee(value) : value;

      value = (comparator || value !== 0) ? value : 0;
      if (isCommon && computed === computed) {
        var seenIndex = seen.length;
        while (seenIndex--) {
          if (seen[seenIndex] === computed) {
            continue outer;
          }
        }
        if (iteratee) {
          seen.push(computed);
        }
        result.push(value);
      }
      else if (!includes(seen, computed, comparator)) {
        if (seen !== result) {
          seen.push(computed);
        }
        result.push(value);
      }
    }
    return result;
  }

  /**
   * The base implementation of `_.unset`.
   *
   * @private
   * @param {Object} object The object to modify.
   * @param {Array|string} path The property path to unset.
   * @returns {boolean} Returns `true` if the property is deleted, else `false`.
   */
  function baseUnset(object, path) {
    path = castPath(path, object);
    object = parent(object, path);
    return object == null || delete object[toKey(last(path))];
  }

  /**
   * The base implementation of `_.update`.
   *
   * @private
   * @param {Object} object The object to modify.
   * @param {Array|string} path The path of the property to update.
   * @param {Function} updater The function to produce the updated value.
   * @param {Function} [customizer] The function to customize path creation.
   * @returns {Object} Returns `object`.
   */
  function baseUpdate(object, path, updater, customizer) {
    return baseSet(object, path, updater(baseGet(object, path)), customizer);
  }

  /**
   * The base implementation of methods like `_.dropWhile` and `_.takeWhile`
   * without support for iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to query.
   * @param {Function} predicate The function invoked per iteration.
   * @param {boolean} [isDrop] Specify dropping elements instead of taking them.
   * @param {boolean} [fromRight] Specify iterating from right to left.
   * @returns {Array} Returns the slice of `array`.
   */
  function baseWhile(array, predicate, isDrop, fromRight) {
    var length = array.length,
        index = fromRight ? length : -1;

    while ((fromRight ? index-- : ++index < length) &&
      predicate(array[index], index, array)) {}

    return isDrop
      ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))
      : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));
  }

  /**
   * The base implementation of `wrapperValue` which returns the result of
   * performing a sequence of actions on the unwrapped `value`, where each
   * successive action is supplied the return value of the previous.
   *
   * @private
   * @param {*} value The unwrapped value.
   * @param {Array} actions Actions to perform to resolve the unwrapped value.
   * @returns {*} Returns the resolved value.
   */
  function baseWrapperValue(value, actions) {
    var result = value;
    if (result instanceof LazyWrapper) {
      result = result.value();
    }
    return arrayReduce(actions, function(result, action) {
      return action.func.apply(action.thisArg, arrayPush([result], action.args));
    }, result);
  }

  /**
   * The base implementation of methods like `_.xor`, without support for
   * iteratee shorthands, that accepts an array of arrays to inspect.
   *
   * @private
   * @param {Array} arrays The arrays to inspect.
   * @param {Function} [iteratee] The iteratee invoked per element.
   * @param {Function} [comparator] The comparator invoked per element.
   * @returns {Array} Returns the new array of values.
   */
  function baseXor(arrays, iteratee, comparator) {
    var length = arrays.length;
    if (length < 2) {
      return length ? baseUniq(arrays[0]) : [];
    }
    var index = -1,
        result = Array(length);

    while (++index < length) {
      var array = arrays[index],
          othIndex = -1;

      while (++othIndex < length) {
        if (othIndex != index) {
          result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
        }
      }
    }
    return baseUniq(baseFlatten(result, 1), iteratee, comparator);
  }

  /**
   * This base implementation of `_.zipObject` which assigns values using `assignFunc`.
   *
   * @private
   * @param {Array} props The property identifiers.
   * @param {Array} values The property values.
   * @param {Function} assignFunc The function to assign values.
   * @returns {Object} Returns the new object.
   */
  function baseZipObject(props, values, assignFunc) {
    var index = -1,
        length = props.length,
        valsLength = values.length,
        result = {};

    while (++index < length) {
      var value = index < valsLength ? values[index] : undefined;
      assignFunc(result, props[index], value);
    }
    return result;
  }

  /**
   * Casts `value` to an empty array if it's not an array like object.
   *
   * @private
   * @param {*} value The value to inspect.
   * @returns {Array|Object} Returns the cast array-like object.
   */
  function castArrayLikeObject(value) {
    return isArrayLikeObject(value) ? value : [];
  }

  /**
   * Casts `value` to `identity` if it's not a function.
   *
   * @private
   * @param {*} value The value to inspect.
   * @returns {Function} Returns cast function.
   */
  function castFunction(value) {
    return typeof value == 'function' ? value : identity;
  }

  /**
   * Casts `value` to a path array if it's not one.
   *
   * @private
   * @param {*} value The value to inspect.
   * @param {Object} [object] The object to query keys on.
   * @returns {Array} Returns the cast property path array.
   */
  function castPath(value, object) {
    if (isArray(value)) {
      return value;
    }
    return isKey(value, object) ? [value] : stringToPath(toString(value));
  }

  /**
   * A `baseRest` alias which can be replaced with `identity` by module
   * replacement plugins.
   *
   * @private
   * @type {Function}
   * @param {Function} func The function to apply a rest parameter to.
   * @returns {Function} Returns the new function.
   */
  var castRest = baseRest;

  /**
   * Casts `array` to a slice if it's needed.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {number} start The start position.
   * @param {number} [end=array.length] The end position.
   * @returns {Array} Returns the cast slice.
   */
  function castSlice(array, start, end) {
    var length = array.length;
    end = end === undefined ? length : end;
    return (!start && end >= length) ? array : baseSlice(array, start, end);
  }

  /**
   * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).
   *
   * @private
   * @param {number|Object} id The timer id or timeout object of the timer to clear.
   */
  var clearTimeout = ctxClearTimeout || function(id) {
    return root.clearTimeout(id);
  };

  /**
   * Creates a clone of  `buffer`.
   *
   * @private
   * @param {Buffer} buffer The buffer to clone.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Buffer} Returns the cloned buffer.
   */
  function cloneBuffer(buffer, isDeep) {
    if (isDeep) {
      return buffer.slice();
    }
    var length = buffer.length,
        result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);

    buffer.copy(result);
    return result;
  }

  /**
   * Creates a clone of `arrayBuffer`.
   *
   * @private
   * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
   * @returns {ArrayBuffer} Returns the cloned array buffer.
   */
  function cloneArrayBuffer(arrayBuffer) {
    var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
    new Uint8Array(result).set(new Uint8Array(arrayBuffer));
    return result;
  }

  /**
   * Creates a clone of `dataView`.
   *
   * @private
   * @param {Object} dataView The data view to clone.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Object} Returns the cloned data view.
   */
  function cloneDataView(dataView, isDeep) {
    var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
    return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
  }

  /**
   * Creates a clone of `map`.
   *
   * @private
   * @param {Object} map The map to clone.
   * @param {Function} cloneFunc The function to clone values.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Object} Returns the cloned map.
   */
  function cloneMap(map, isDeep, cloneFunc) {
    var array = isDeep ? cloneFunc(mapToArray(map), CLONE_DEEP_FLAG) : mapToArray(map);
    return arrayReduce(array, addMapEntry, new map.constructor);
  }

  /**
   * Creates a clone of `regexp`.
   *
   * @private
   * @param {Object} regexp The regexp to clone.
   * @returns {Object} Returns the cloned regexp.
   */
  function cloneRegExp(regexp) {
    var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
    result.lastIndex = regexp.lastIndex;
    return result;
  }

  /**
   * Creates a clone of `set`.
   *
   * @private
   * @param {Object} set The set to clone.
   * @param {Function} cloneFunc The function to clone values.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Object} Returns the cloned set.
   */
  function cloneSet(set, isDeep, cloneFunc) {
    var array = isDeep ? cloneFunc(setToArray(set), CLONE_DEEP_FLAG) : setToArray(set);
    return arrayReduce(array, addSetEntry, new set.constructor);
  }

  /**
   * Creates a clone of the `symbol` object.
   *
   * @private
   * @param {Object} symbol The symbol object to clone.
   * @returns {Object} Returns the cloned symbol object.
   */
  function cloneSymbol(symbol) {
    return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
  }

  /**
   * Creates a clone of `typedArray`.
   *
   * @private
   * @param {Object} typedArray The typed array to clone.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Object} Returns the cloned typed array.
   */
  function cloneTypedArray(typedArray, isDeep) {
    var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
    return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
  }

  /**
   * Compares values to sort them in ascending order.
   *
   * @private
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {number} Returns the sort order indicator for `value`.
   */
  function compareAscending(value, other) {
    if (value !== other) {
      var valIsDefined = value !== undefined,
          valIsNull = value === null,
          valIsReflexive = value === value,
          valIsSymbol = isSymbol(value);

      var othIsDefined = other !== undefined,
          othIsNull = other === null,
          othIsReflexive = other === other,
          othIsSymbol = isSymbol(other);

      if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
          (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
          (valIsNull && othIsDefined && othIsReflexive) ||
          (!valIsDefined && othIsReflexive) ||
          !valIsReflexive) {
        return 1;
      }
      if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
          (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
          (othIsNull && valIsDefined && valIsReflexive) ||
          (!othIsDefined && valIsReflexive) ||
          !othIsReflexive) {
        return -1;
      }
    }
    return 0;
  }

  /**
   * Used by `_.orderBy` to compare multiple properties of a value to another
   * and stable sort them.
   *
   * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
   * specify an order of "desc" for descending or "asc" for ascending sort order
   * of corresponding values.
   *
   * @private
   * @param {Object} object The object to compare.
   * @param {Object} other The other object to compare.
   * @param {boolean[]|string[]} orders The order to sort by for each property.
   * @returns {number} Returns the sort order indicator for `object`.
   */
  function compareMultiple(object, other, orders) {
    var index = -1,
        objCriteria = object.criteria,
        othCriteria = other.criteria,
        length = objCriteria.length,
        ordersLength = orders.length;

    while (++index < length) {
      var result = compareAscending(objCriteria[index], othCriteria[index]);
      if (result) {
        if (index >= ordersLength) {
          return result;
        }
        var order = orders[index];
        return result * (order == 'desc' ? -1 : 1);
      }
    }
    // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
    // that causes it, under certain circumstances, to provide the same value for
    // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247
    // for more details.
    //
    // This also ensures a stable sort in V8 and other engines.
    // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
    return object.index - other.index;
  }

  /**
   * Creates an array that is the composition of partially applied arguments,
   * placeholders, and provided arguments into a single array of arguments.
   *
   * @private
   * @param {Array} args The provided arguments.
   * @param {Array} partials The arguments to prepend to those provided.
   * @param {Array} holders The `partials` placeholder indexes.
   * @params {boolean} [isCurried] Specify composing for a curried function.
   * @returns {Array} Returns the new array of composed arguments.
   */
  function composeArgs(args, partials, holders, isCurried) {
    var argsIndex = -1,
        argsLength = args.length,
        holdersLength = holders.length,
        leftIndex = -1,
        leftLength = partials.length,
        rangeLength = nativeMax(argsLength - holdersLength, 0),
        result = Array(leftLength + rangeLength),
        isUncurried = !isCurried;

    while (++leftIndex < leftLength) {
      result[leftIndex] = partials[leftIndex];
    }
    while (++argsIndex < holdersLength) {
      if (isUncurried || argsIndex < argsLength) {
        result[holders[argsIndex]] = args[argsIndex];
      }
    }
    while (rangeLength--) {
      result[leftIndex++] = args[argsIndex++];
    }
    return result;
  }

  /**
   * This function is like `composeArgs` except that the arguments composition
   * is tailored for `_.partialRight`.
   *
   * @private
   * @param {Array} args The provided arguments.
   * @param {Array} partials The arguments to append to those provided.
   * @param {Array} holders The `partials` placeholder indexes.
   * @params {boolean} [isCurried] Specify composing for a curried function.
   * @returns {Array} Returns the new array of composed arguments.
   */
  function composeArgsRight(args, partials, holders, isCurried) {
    var argsIndex = -1,
        argsLength = args.length,
        holdersIndex = -1,
        holdersLength = holders.length,
        rightIndex = -1,
        rightLength = partials.length,
        rangeLength = nativeMax(argsLength - holdersLength, 0),
        result = Array(rangeLength + rightLength),
        isUncurried = !isCurried;

    while (++argsIndex < rangeLength) {
      result[argsIndex] = args[argsIndex];
    }
    var offset = argsIndex;
    while (++rightIndex < rightLength) {
      result[offset + rightIndex] = partials[rightIndex];
    }
    while (++holdersIndex < holdersLength) {
      if (isUncurried || argsIndex < argsLength) {
        result[offset + holders[holdersIndex]] = args[argsIndex++];
      }
    }
    return result;
  }

  /**
   * Copies the values of `source` to `array`.
   *
   * @private
   * @param {Array} source The array to copy values from.
   * @param {Array} [array=[]] The array to copy values to.
   * @returns {Array} Returns `array`.
   */
  function copyArray(source, array) {
    var index = -1,
        length = source.length;

    array || (array = Array(length));
    while (++index < length) {
      array[index] = source[index];
    }
    return array;
  }

  /**
   * Copies properties of `source` to `object`.
   *
   * @private
   * @param {Object} source The object to copy properties from.
   * @param {Array} props The property identifiers to copy.
   * @param {Object} [object={}] The object to copy properties to.
   * @param {Function} [customizer] The function to customize copied values.
   * @returns {Object} Returns `object`.
   */
  function copyObject(source, props, object, customizer) {
    var isNew = !object;
    object || (object = {});

    var index = -1,
        length = props.length;

    while (++index < length) {
      var key = props[index];

      var newValue = customizer
        ? customizer(object[key], source[key], key, object, source)
        : undefined;

      if (newValue === undefined) {
        newValue = source[key];
      }
      if (isNew) {
        baseAssignValue(object, key, newValue);
      } else {
        assignValue(object, key, newValue);
      }
    }
    return object;
  }

  /**
   * Copies own symbols of `source` to `object`.
   *
   * @private
   * @param {Object} source The object to copy symbols from.
   * @param {Object} [object={}] The object to copy symbols to.
   * @returns {Object} Returns `object`.
   */
  function copySymbols(source, object) {
    return copyObject(source, getSymbols(source), object);
  }

  /**
   * Copies own and inherited symbols of `source` to `object`.
   *
   * @private
   * @param {Object} source The object to copy symbols from.
   * @param {Object} [object={}] The object to copy symbols to.
   * @returns {Object} Returns `object`.
   */
  function copySymbolsIn(source, object) {
    return copyObject(source, getSymbolsIn(source), object);
  }

  /**
   * Creates a function like `_.groupBy`.
   *
   * @private
   * @param {Function} setter The function to set accumulator values.
   * @param {Function} [initializer] The accumulator object initializer.
   * @returns {Function} Returns the new aggregator function.
   */
  function createAggregator(setter, initializer) {
    return function(collection, iteratee) {
      var func = isArray(collection) ? arrayAggregator : baseAggregator,
          accumulator = initializer ? initializer() : {};

      return func(collection, setter, getIteratee(iteratee, 2), accumulator);
    };
  }

  /**
   * Creates a function like `_.assign`.
   *
   * @private
   * @param {Function} assigner The function to assign values.
   * @returns {Function} Returns the new assigner function.
   */
  function createAssigner(assigner) {
    return baseRest(function(object, sources) {
      var index = -1,
          length = sources.length,
          customizer = length > 1 ? sources[length - 1] : undefined,
          guard = length > 2 ? sources[2] : undefined;

      customizer = (assigner.length > 3 && typeof customizer == 'function')
        ? (length--, customizer)
        : undefined;

      if (guard && isIterateeCall(sources[0], sources[1], guard)) {
        customizer = length < 3 ? undefined : customizer;
        length = 1;
      }
      object = Object(object);
      while (++index < length) {
        var source = sources[index];
        if (source) {
          assigner(object, source, index, customizer);
        }
      }
      return object;
    });
  }

  /**
   * Creates a `baseEach` or `baseEachRight` function.
   *
   * @private
   * @param {Function} eachFunc The function to iterate over a collection.
   * @param {boolean} [fromRight] Specify iterating from right to left.
   * @returns {Function} Returns the new base function.
   */
  function createBaseEach(eachFunc, fromRight) {
    return function(collection, iteratee) {
      if (collection == null) {
        return collection;
      }
      if (!isArrayLike(collection)) {
        return eachFunc(collection, iteratee);
      }
      var length = collection.length,
          index = fromRight ? length : -1,
          iterable = Object(collection);

      while ((fromRight ? index-- : ++index < length)) {
        if (iteratee(iterable[index], index, iterable) === false) {
          break;
        }
      }
      return collection;
    };
  }

  /**
   * Creates a base function for methods like `_.forIn` and `_.forOwn`.
   *
   * @private
   * @param {boolean} [fromRight] Specify iterating from right to left.
   * @returns {Function} Returns the new base function.
   */
  function createBaseFor(fromRight) {
    return function(object, iteratee, keysFunc) {
      var index = -1,
          iterable = Object(object),
          props = keysFunc(object),
          length = props.length;

      while (length--) {
        var key = props[fromRight ? length : ++index];
        if (iteratee(iterable[key], key, iterable) === false) {
          break;
        }
      }
      return object;
    };
  }

  /**
   * Creates a function that wraps `func` to invoke it with the optional `this`
   * binding of `thisArg`.
   *
   * @private
   * @param {Function} func The function to wrap.
   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
   * @param {*} [thisArg] The `this` binding of `func`.
   * @returns {Function} Returns the new wrapped function.
   */
  function createBind(func, bitmask, thisArg) {
    var isBind = bitmask & WRAP_BIND_FLAG,
        Ctor = createCtor(func);

    function wrapper() {
      var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
      return fn.apply(isBind ? thisArg : this, arguments);
    }
    return wrapper;
  }

  /**
   * Creates a function like `_.lowerFirst`.
   *
   * @private
   * @param {string} methodName The name of the `String` case method to use.
   * @returns {Function} Returns the new case function.
   */
  function createCaseFirst(methodName) {
    return function(string) {
      string = toString(string);

      var strSymbols = hasUnicode(string)
        ? stringToArray(string)
        : undefined;

      var chr = strSymbols
        ? strSymbols[0]
        : string.charAt(0);

      var trailing = strSymbols
        ? castSlice(strSymbols, 1).join('')
        : string.slice(1);

      return chr[methodName]() + trailing;
    };
  }

  /**
   * Creates a function like `_.camelCase`.
   *
   * @private
   * @param {Function} callback The function to combine each word.
   * @returns {Function} Returns the new compounder function.
   */
  function createCompounder(callback) {
    return function(string) {
      return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
    };
  }

  /**
   * Creates a function that produces an instance of `Ctor` regardless of
   * whether it was invoked as part of a `new` expression or by `call` or `apply`.
   *
   * @private
   * @param {Function} Ctor The constructor to wrap.
   * @returns {Function} Returns the new wrapped function.
   */
  function createCtor(Ctor) {
    return function() {
      // Use a `switch` statement to work with class constructors. See
      // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
      // for more details.
      var args = arguments;
      switch (args.length) {
        case 0: return new Ctor;
        case 1: return new Ctor(args[0]);
        case 2: return new Ctor(args[0], args[1]);
        case 3: return new Ctor(args[0], args[1], args[2]);
        case 4: return new Ctor(args[0], args[1], args[2], args[3]);
        case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);
        case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
        case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
      }
      var thisBinding = baseCreate(Ctor.prototype),
          result = Ctor.apply(thisBinding, args);

      // Mimic the constructor's `return` behavior.
      // See https://es5.github.io/#x13.2.2 for more details.
      return isObject(result) ? result : thisBinding;
    };
  }

  /**
   * Creates a function that wraps `func` to enable currying.
   *
   * @private
   * @param {Function} func The function to wrap.
   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
   * @param {number} arity The arity of `func`.
   * @returns {Function} Returns the new wrapped function.
   */
  function createCurry(func, bitmask, arity) {
    var Ctor = createCtor(func);

    function wrapper() {
      var length = arguments.length,
          args = Array(length),
          index = length,
          placeholder = getHolder(wrapper);

      while (index--) {
        args[index] = arguments[index];
      }
      var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)
        ? []
        : replaceHolders(args, placeholder);

      length -= holders.length;
      if (length < arity) {
        return createRecurry(
          func, bitmask, createHybrid, wrapper.placeholder, undefined,
          args, holders, undefined, undefined, arity - length);
      }
      var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
      return apply(fn, this, args);
    }
    return wrapper;
  }

  /**
   * Creates a `_.find` or `_.findLast` function.
   *
   * @private
   * @param {Function} findIndexFunc The function to find the collection index.
   * @returns {Function} Returns the new find function.
   */
  function createFind(findIndexFunc) {
    return function(collection, predicate, fromIndex) {
      var iterable = Object(collection);
      if (!isArrayLike(collection)) {
        var iteratee = getIteratee(predicate, 3);
        collection = keys(collection);
        predicate = function(key) { return iteratee(iterable[key], key, iterable); };
      }
      var index = findIndexFunc(collection, predicate, fromIndex);
      return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
    };
  }

  /**
   * Creates a `_.flow` or `_.flowRight` function.
   *
   * @private
   * @param {boolean} [fromRight] Specify iterating from right to left.
   * @returns {Function} Returns the new flow function.
   */
  function createFlow(fromRight) {
    return flatRest(function(funcs) {
      var length = funcs.length,
          index = length,
          prereq = LodashWrapper.prototype.thru;

      if (fromRight) {
        funcs.reverse();
      }
      while (index--) {
        var func = funcs[index];
        if (typeof func != 'function') {
          throw new TypeError(FUNC_ERROR_TEXT);
        }
        if (prereq && !wrapper && getFuncName(func) == 'wrapper') {
          var wrapper = new LodashWrapper([], true);
        }
      }
      index = wrapper ? index : length;
      while (++index < length) {
        func = funcs[index];

        var funcName = getFuncName(func),
            data = funcName == 'wrapper' ? getData(func) : undefined;

        if (data && isLaziable(data[0]) &&
              data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&
              !data[4].length && data[9] == 1
            ) {
          wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
        } else {
          wrapper = (func.length == 1 && isLaziable(func))
            ? wrapper[funcName]()
            : wrapper.thru(func);
        }
      }
      return function() {
        var args = arguments,
            value = args[0];

        if (wrapper && args.length == 1 && isArray(value)) {
          return wrapper.plant(value).value();
        }
        var index = 0,
            result = length ? funcs[index].apply(this, args) : value;

        while (++index < length) {
          result = funcs[index].call(this, result);
        }
        return result;
      };
    });
  }

  /**
   * Creates a function that wraps `func` to invoke it with optional `this`
   * binding of `thisArg`, partial application, and currying.
   *
   * @private
   * @param {Function|string} func The function or method name to wrap.
   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
   * @param {*} [thisArg] The `this` binding of `func`.
   * @param {Array} [partials] The arguments to prepend to those provided to
   *  the new function.
   * @param {Array} [holders] The `partials` placeholder indexes.
   * @param {Array} [partialsRight] The arguments to append to those provided
   *  to the new function.
   * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
   * @param {Array} [argPos] The argument positions of the new function.
   * @param {number} [ary] The arity cap of `func`.
   * @param {number} [arity] The arity of `func`.
   * @returns {Function} Returns the new wrapped function.
   */
  function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
    var isAry = bitmask & WRAP_ARY_FLAG,
        isBind = bitmask & WRAP_BIND_FLAG,
        isBindKey = bitmask & WRAP_BIND_KEY_FLAG,
        isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),
        isFlip = bitmask & WRAP_FLIP_FLAG,
        Ctor = isBindKey ? undefined : createCtor(func);

    function wrapper() {
      var length = arguments.length,
          args = Array(length),
          index = length;

      while (index--) {
        args[index] = arguments[index];
      }
      if (isCurried) {
        var placeholder = getHolder(wrapper),
            holdersCount = countHolders(args, placeholder);
      }
      if (partials) {
        args = composeArgs(args, partials, holders, isCurried);
      }
      if (partialsRight) {
        args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
      }
      length -= holdersCount;
      if (isCurried && length < arity) {
        var newHolders = replaceHolders(args, placeholder);
        return createRecurry(
          func, bitmask, createHybrid, wrapper.placeholder, thisArg,
          args, newHolders, argPos, ary, arity - length
        );
      }
      var thisBinding = isBind ? thisArg : this,
          fn = isBindKey ? thisBinding[func] : func;

      length = args.length;
      if (argPos) {
        args = reorder(args, argPos);
      } else if (isFlip && length > 1) {
        args.reverse();
      }
      if (isAry && ary < length) {
        args.length = ary;
      }
      if (this && this !== root && this instanceof wrapper) {
        fn = Ctor || createCtor(fn);
      }
      return fn.apply(thisBinding, args);
    }
    return wrapper;
  }

  /**
   * Creates a function like `_.invertBy`.
   *
   * @private
   * @param {Function} setter The function to set accumulator values.
   * @param {Function} toIteratee The function to resolve iteratees.
   * @returns {Function} Returns the new inverter function.
   */
  function createInverter(setter, toIteratee) {
    return function(object, iteratee) {
      return baseInverter(object, setter, toIteratee(iteratee), {});
    };
  }

  /**
   * Creates a function that performs a mathematical operation on two values.
   *
   * @private
   * @param {Function} operator The function to perform the operation.
   * @param {number} [defaultValue] The value used for `undefined` arguments.
   * @returns {Function} Returns the new mathematical operation function.
   */
  function createMathOperation(operator, defaultValue) {
    return function(value, other) {
      var result;
      if (value === undefined && other === undefined) {
        return defaultValue;
      }
      if (value !== undefined) {
        result = value;
      }
      if (other !== undefined) {
        if (result === undefined) {
          return other;
        }
        if (typeof value == 'string' || typeof other == 'string') {
          value = baseToString(value);
          other = baseToString(other);
        } else {
          value = baseToNumber(value);
          other = baseToNumber(other);
        }
        result = operator(value, other);
      }
      return result;
    };
  }

  /**
   * Creates a function like `_.over`.
   *
   * @private
   * @param {Function} arrayFunc The function to iterate over iteratees.
   * @returns {Function} Returns the new over function.
   */
  function createOver(arrayFunc) {
    return flatRest(function(iteratees) {
      iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
      return baseRest(function(args) {
        var thisArg = this;
        return arrayFunc(iteratees, function(iteratee) {
          return apply(iteratee, thisArg, args);
        });
      });
    });
  }

  /**
   * Creates the padding for `string` based on `length`. The `chars` string
   * is truncated if the number of characters exceeds `length`.
   *
   * @private
   * @param {number} length The padding length.
   * @param {string} [chars=' '] The string used as padding.
   * @returns {string} Returns the padding for `string`.
   */
  function createPadding(length, chars) {
    chars = chars === undefined ? ' ' : baseToString(chars);

    var charsLength = chars.length;
    if (charsLength < 2) {
      return charsLength ? baseRepeat(chars, length) : chars;
    }
    var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
    return hasUnicode(chars)
      ? castSlice(stringToArray(result), 0, length).join('')
      : result.slice(0, length);
  }

  /**
   * Creates a function that wraps `func` to invoke it with the `this` binding
   * of `thisArg` and `partials` prepended to the arguments it receives.
   *
   * @private
   * @param {Function} func The function to wrap.
   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
   * @param {*} thisArg The `this` binding of `func`.
   * @param {Array} partials The arguments to prepend to those provided to
   *  the new function.
   * @returns {Function} Returns the new wrapped function.
   */
  function createPartial(func, bitmask, thisArg, partials) {
    var isBind = bitmask & WRAP_BIND_FLAG,
        Ctor = createCtor(func);

    function wrapper() {
      var argsIndex = -1,
          argsLength = arguments.length,
          leftIndex = -1,
          leftLength = partials.length,
          args = Array(leftLength + argsLength),
          fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;

      while (++leftIndex < leftLength) {
        args[leftIndex] = partials[leftIndex];
      }
      while (argsLength--) {
        args[leftIndex++] = arguments[++argsIndex];
      }
      return apply(fn, isBind ? thisArg : this, args);
    }
    return wrapper;
  }

  /**
   * Creates a `_.range` or `_.rangeRight` function.
   *
   * @private
   * @param {boolean} [fromRight] Specify iterating from right to left.
   * @returns {Function} Returns the new range function.
   */
  function createRange(fromRight) {
    return function(start, end, step) {
      if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {
        end = step = undefined;
      }
      // Ensure the sign of `-0` is preserved.
      start = toFinite(start);
      if (end === undefined) {
        end = start;
        start = 0;
      } else {
        end = toFinite(end);
      }
      step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);
      return baseRange(start, end, step, fromRight);
    };
  }

  /**
   * Creates a function that performs a relational operation on two values.
   *
   * @private
   * @param {Function} operator The function to perform the operation.
   * @returns {Function} Returns the new relational operation function.
   */
  function createRelationalOperation(operator) {
    return function(value, other) {
      if (!(typeof value == 'string' && typeof other == 'string')) {
        value = toNumber(value);
        other = toNumber(other);
      }
      return operator(value, other);
    };
  }

  /**
   * Creates a function that wraps `func` to continue currying.
   *
   * @private
   * @param {Function} func The function to wrap.
   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
   * @param {Function} wrapFunc The function to create the `func` wrapper.
   * @param {*} placeholder The placeholder value.
   * @param {*} [thisArg] The `this` binding of `func`.
   * @param {Array} [partials] The arguments to prepend to those provided to
   *  the new function.
   * @param {Array} [holders] The `partials` placeholder indexes.
   * @param {Array} [argPos] The argument positions of the new function.
   * @param {number} [ary] The arity cap of `func`.
   * @param {number} [arity] The arity of `func`.
   * @returns {Function} Returns the new wrapped function.
   */
  function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
    var isCurry = bitmask & WRAP_CURRY_FLAG,
        newHolders = isCurry ? holders : undefined,
        newHoldersRight = isCurry ? undefined : holders,
        newPartials = isCurry ? partials : undefined,
        newPartialsRight = isCurry ? undefined : partials;

    bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);
    bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);

    if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
      bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
    }
    var newData = [
      func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
      newHoldersRight, argPos, ary, arity
    ];

    var result = wrapFunc.apply(undefined, newData);
    if (isLaziable(func)) {
      setData(result, newData);
    }
    result.placeholder = placeholder;
    return setWrapToString(result, func, bitmask);
  }

  /**
   * Creates a function like `_.round`.
   *
   * @private
   * @param {string} methodName The name of the `Math` method to use when rounding.
   * @returns {Function} Returns the new round function.
   */
  function createRound(methodName) {
    var func = Math[methodName];
    return function(number, precision) {
      number = toNumber(number);
      precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
      if (precision) {
        // Shift with exponential notation to avoid floating-point issues.
        // See [MDN](https://mdn.io/round#Examples) for more details.
        var pair = (toString(number) + 'e').split('e'),
            value = func(pair[0] + 'e' + (+pair[1] + precision));

        pair = (toString(value) + 'e').split('e');
        return +(pair[0] + 'e' + (+pair[1] - precision));
      }
      return func(number);
    };
  }

  /**
   * Creates a set object of `values`.
   *
   * @private
   * @param {Array} values The values to add to the set.
   * @returns {Object} Returns the new set.
   */
  var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {
    return new Set(values);
  };

  /**
   * Creates a `_.toPairs` or `_.toPairsIn` function.
   *
   * @private
   * @param {Function} keysFunc The function to get the keys of a given object.
   * @returns {Function} Returns the new pairs function.
   */
  function createToPairs(keysFunc) {
    return function(object) {
      var tag = getTag(object);
      if (tag == mapTag) {
        return mapToArray(object);
      }
      if (tag == setTag) {
        return setToPairs(object);
      }
      return baseToPairs(object, keysFunc(object));
    };
  }

  /**
   * Creates a function that either curries or invokes `func` with optional
   * `this` binding and partially applied arguments.
   *
   * @private
   * @param {Function|string} func The function or method name to wrap.
   * @param {number} bitmask The bitmask flags.
   *    1 - `_.bind`
   *    2 - `_.bindKey`
   *    4 - `_.curry` or `_.curryRight` of a bound function
   *    8 - `_.curry`
   *   16 - `_.curryRight`
   *   32 - `_.partial`
   *   64 - `_.partialRight`
   *  128 - `_.rearg`
   *  256 - `_.ary`
   *  512 - `_.flip`
   * @param {*} [thisArg] The `this` binding of `func`.
   * @param {Array} [partials] The arguments to be partially applied.
   * @param {Array} [holders] The `partials` placeholder indexes.
   * @param {Array} [argPos] The argument positions of the new function.
   * @param {number} [ary] The arity cap of `func`.
   * @param {number} [arity] The arity of `func`.
   * @returns {Function} Returns the new wrapped function.
   */
  function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
    var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
    if (!isBindKey && typeof func != 'function') {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    var length = partials ? partials.length : 0;
    if (!length) {
      bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
      partials = holders = undefined;
    }
    ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);
    arity = arity === undefined ? arity : toInteger(arity);
    length -= holders ? holders.length : 0;

    if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
      var partialsRight = partials,
          holdersRight = holders;

      partials = holders = undefined;
    }
    var data = isBindKey ? undefined : getData(func);

    var newData = [
      func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,
      argPos, ary, arity
    ];

    if (data) {
      mergeData(newData, data);
    }
    func = newData[0];
    bitmask = newData[1];
    thisArg = newData[2];
    partials = newData[3];
    holders = newData[4];
    arity = newData[9] = newData[9] === undefined
      ? (isBindKey ? 0 : func.length)
      : nativeMax(newData[9] - length, 0);

    if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
      bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
    }
    if (!bitmask || bitmask == WRAP_BIND_FLAG) {
      var result = createBind(func, bitmask, thisArg);
    } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
      result = createCurry(func, bitmask, arity);
    } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
      result = createPartial(func, bitmask, thisArg, partials);
    } else {
      result = createHybrid.apply(undefined, newData);
    }
    var setter = data ? baseSetData : setData;
    return setWrapToString(setter(result, newData), func, bitmask);
  }

  /**
   * Used by `_.defaults` to customize its `_.assignIn` use to assign properties
   * of source objects to the destination object for all destination properties
   * that resolve to `undefined`.
   *
   * @private
   * @param {*} objValue The destination value.
   * @param {*} srcValue The source value.
   * @param {string} key The key of the property to assign.
   * @param {Object} object The parent object of `objValue`.
   * @returns {*} Returns the value to assign.
   */
  function customDefaultsAssignIn(objValue, srcValue, key, object) {
    if (objValue === undefined ||
        (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {
      return srcValue;
    }
    return objValue;
  }

  /**
   * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source
   * objects into destination objects that are passed thru.
   *
   * @private
   * @param {*} objValue The destination value.
   * @param {*} srcValue The source value.
   * @param {string} key The key of the property to merge.
   * @param {Object} object The parent object of `objValue`.
   * @param {Object} source The parent object of `srcValue`.
   * @param {Object} [stack] Tracks traversed source values and their merged
   *  counterparts.
   * @returns {*} Returns the value to assign.
   */
  function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
    if (isObject(objValue) && isObject(srcValue)) {
      // Recursively merge objects and arrays (susceptible to call stack limits).
      stack.set(srcValue, objValue);
      baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);
      stack['delete'](srcValue);
    }
    return objValue;
  }

  /**
   * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
   * objects.
   *
   * @private
   * @param {*} value The value to inspect.
   * @param {string} key The key of the property to inspect.
   * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
   */
  function customOmitClone(value) {
    return isPlainObject(value) ? undefined : value;
  }

  /**
   * A specialized version of `baseIsEqualDeep` for arrays with support for
   * partial deep comparisons.
   *
   * @private
   * @param {Array} array The array to compare.
   * @param {Array} other The other array to compare.
   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
   * @param {Function} customizer The function to customize comparisons.
   * @param {Function} equalFunc The function to determine equivalents of values.
   * @param {Object} stack Tracks traversed `array` and `other` objects.
   * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
   */
  function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
    var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
        arrLength = array.length,
        othLength = other.length;

    if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
      return false;
    }
    // Assume cyclic values are equal.
    var stacked = stack.get(array);
    if (stacked && stack.get(other)) {
      return stacked == other;
    }
    var index = -1,
        result = true,
        seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;

    stack.set(array, other);
    stack.set(other, array);

    // Ignore non-index properties.
    while (++index < arrLength) {
      var arrValue = array[index],
          othValue = other[index];

      if (customizer) {
        var compared = isPartial
          ? customizer(othValue, arrValue, index, other, array, stack)
          : customizer(arrValue, othValue, index, array, other, stack);
      }
      if (compared !== undefined) {
        if (compared) {
          continue;
        }
        result = false;
        break;
      }
      // Recursively compare arrays (susceptible to call stack limits).
      if (seen) {
        if (!arraySome(other, function(othValue, othIndex) {
              if (!cacheHas(seen, othIndex) &&
                  (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
                return seen.push(othIndex);
              }
            })) {
          result = false;
          break;
        }
      } else if (!(
            arrValue === othValue ||
              equalFunc(arrValue, othValue, bitmask, customizer, stack)
          )) {
        result = false;
        break;
      }
    }
    stack['delete'](array);
    stack['delete'](other);
    return result;
  }

  /**
   * A specialized version of `baseIsEqualDeep` for comparing objects of
   * the same `toStringTag`.
   *
   * **Note:** This function only supports comparing values with tags of
   * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
   *
   * @private
   * @param {Object} object The object to compare.
   * @param {Object} other The other object to compare.
   * @param {string} tag The `toStringTag` of the objects to compare.
   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
   * @param {Function} customizer The function to customize comparisons.
   * @param {Function} equalFunc The function to determine equivalents of values.
   * @param {Object} stack Tracks traversed `object` and `other` objects.
   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
   */
  function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
    switch (tag) {
      case dataViewTag:
        if ((object.byteLength != other.byteLength) ||
            (object.byteOffset != other.byteOffset)) {
          return false;
        }
        object = object.buffer;
        other = other.buffer;

      case arrayBufferTag:
        if ((object.byteLength != other.byteLength) ||
            !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
          return false;
        }
        return true;

      case boolTag:
      case dateTag:
      case numberTag:
        // Coerce booleans to `1` or `0` and dates to milliseconds.
        // Invalid dates are coerced to `NaN`.
        return eq(+object, +other);

      case errorTag:
        return object.name == other.name && object.message == other.message;

      case regexpTag:
      case stringTag:
        // Coerce regexes to strings and treat strings, primitives and objects,
        // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
        // for more details.
        return object == (other + '');

      case mapTag:
        var convert = mapToArray;

      case setTag:
        var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
        convert || (convert = setToArray);

        if (object.size != other.size && !isPartial) {
          return false;
        }
        // Assume cyclic values are equal.
        var stacked = stack.get(object);
        if (stacked) {
          return stacked == other;
        }
        bitmask |= COMPARE_UNORDERED_FLAG;

        // Recursively compare objects (susceptible to call stack limits).
        stack.set(object, other);
        var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
        stack['delete'](object);
        return result;

      case symbolTag:
        if (symbolValueOf) {
          return symbolValueOf.call(object) == symbolValueOf.call(other);
        }
    }
    return false;
  }

  /**
   * A specialized version of `baseIsEqualDeep` for objects with support for
   * partial deep comparisons.
   *
   * @private
   * @param {Object} object The object to compare.
   * @param {Object} other The other object to compare.
   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
   * @param {Function} customizer The function to customize comparisons.
   * @param {Function} equalFunc The function to determine equivalents of values.
   * @param {Object} stack Tracks traversed `object` and `other` objects.
   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
   */
  function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
    var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
        objProps = getAllKeys(object),
        objLength = objProps.length,
        othProps = getAllKeys(other),
        othLength = othProps.length;

    if (objLength != othLength && !isPartial) {
      return false;
    }
    var index = objLength;
    while (index--) {
      var key = objProps[index];
      if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
        return false;
      }
    }
    // Assume cyclic values are equal.
    var stacked = stack.get(object);
    if (stacked && stack.get(other)) {
      return stacked == other;
    }
    var result = true;
    stack.set(object, other);
    stack.set(other, object);

    var skipCtor = isPartial;
    while (++index < objLength) {
      key = objProps[index];
      var objValue = object[key],
          othValue = other[key];

      if (customizer) {
        var compared = isPartial
          ? customizer(othValue, objValue, key, other, object, stack)
          : customizer(objValue, othValue, key, object, other, stack);
      }
      // Recursively compare objects (susceptible to call stack limits).
      if (!(compared === undefined
            ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
            : compared
          )) {
        result = false;
        break;
      }
      skipCtor || (skipCtor = key == 'constructor');
    }
    if (result && !skipCtor) {
      var objCtor = object.constructor,
          othCtor = other.constructor;

      // Non `Object` object instances with different constructors are not equal.
      if (objCtor != othCtor &&
          ('constructor' in object && 'constructor' in other) &&
          !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
            typeof othCtor == 'function' && othCtor instanceof othCtor)) {
        result = false;
      }
    }
    stack['delete'](object);
    stack['delete'](other);
    return result;
  }

  /**
   * A specialized version of `baseRest` which flattens the rest array.
   *
   * @private
   * @param {Function} func The function to apply a rest parameter to.
   * @returns {Function} Returns the new function.
   */
  function flatRest(func) {
    return setToString(overRest(func, undefined, flatten), func + '');
  }

  /**
   * Creates an array of own enumerable property names and symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names and symbols.
   */
  function getAllKeys(object) {
    return baseGetAllKeys(object, keys, getSymbols);
  }

  /**
   * Creates an array of own and inherited enumerable property names and
   * symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names and symbols.
   */
  function getAllKeysIn(object) {
    return baseGetAllKeys(object, keysIn, getSymbolsIn);
  }

  /**
   * Gets metadata for `func`.
   *
   * @private
   * @param {Function} func The function to query.
   * @returns {*} Returns the metadata for `func`.
   */
  var getData = !metaMap ? noop : function(func) {
    return metaMap.get(func);
  };

  /**
   * Gets the name of `func`.
   *
   * @private
   * @param {Function} func The function to query.
   * @returns {string} Returns the function name.
   */
  function getFuncName(func) {
    var result = (func.name + ''),
        array = realNames[result],
        length = hasOwnProperty.call(realNames, result) ? array.length : 0;

    while (length--) {
      var data = array[length],
          otherFunc = data.func;
      if (otherFunc == null || otherFunc == func) {
        return data.name;
      }
    }
    return result;
  }

  /**
   * Gets the argument placeholder value for `func`.
   *
   * @private
   * @param {Function} func The function to inspect.
   * @returns {*} Returns the placeholder value.
   */
  function getHolder(func) {
    var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;
    return object.placeholder;
  }

  /**
   * Gets the appropriate "iteratee" function. If `_.iteratee` is customized,
   * this function returns the custom method, otherwise it returns `baseIteratee`.
   * If arguments are provided, the chosen function is invoked with them and
   * its result is returned.
   *
   * @private
   * @param {*} [value] The value to convert to an iteratee.
   * @param {number} [arity] The arity of the created iteratee.
   * @returns {Function} Returns the chosen function or its result.
   */
  function getIteratee() {
    var result = lodash.iteratee || iteratee;
    result = result === iteratee ? baseIteratee : result;
    return arguments.length ? result(arguments[0], arguments[1]) : result;
  }

  /**
   * Gets the data for `map`.
   *
   * @private
   * @param {Object} map The map to query.
   * @param {string} key The reference key.
   * @returns {*} Returns the map data.
   */
  function getMapData(map, key) {
    var data = map.__data__;
    return isKeyable(key)
      ? data[typeof key == 'string' ? 'string' : 'hash']
      : data.map;
  }

  /**
   * Gets the property names, values, and compare flags of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the match data of `object`.
   */
  function getMatchData(object) {
    var result = keys(object),
        length = result.length;

    while (length--) {
      var key = result[length],
          value = object[key];

      result[length] = [key, value, isStrictComparable(value)];
    }
    return result;
  }

  /**
   * Gets the native function at `key` of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {string} key The key of the method to get.
   * @returns {*} Returns the function if it's native, else `undefined`.
   */
  function getNative(object, key) {
    var value = getValue(object, key);
    return baseIsNative(value) ? value : undefined;
  }

  /**
   * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
   *
   * @private
   * @param {*} value The value to query.
   * @returns {string} Returns the raw `toStringTag`.
   */
  function getRawTag(value) {
    var isOwn = hasOwnProperty.call(value, symToStringTag),
        tag = value[symToStringTag];

    try {
      value[symToStringTag] = undefined;
      var unmasked = true;
    } catch (e) {}

    var result = nativeObjectToString.call(value);
    if (unmasked) {
      if (isOwn) {
        value[symToStringTag] = tag;
      } else {
        delete value[symToStringTag];
      }
    }
    return result;
  }

  /**
   * Creates an array of the own enumerable symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of symbols.
   */
  var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
    if (object == null) {
      return [];
    }
    object = Object(object);
    return arrayFilter(nativeGetSymbols(object), function(symbol) {
      return propertyIsEnumerable.call(object, symbol);
    });
  };

  /**
   * Creates an array of the own and inherited enumerable symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of symbols.
   */
  var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
    var result = [];
    while (object) {
      arrayPush(result, getSymbols(object));
      object = getPrototype(object);
    }
    return result;
  };

  /**
   * Gets the `toStringTag` of `value`.
   *
   * @private
   * @param {*} value The value to query.
   * @returns {string} Returns the `toStringTag`.
   */
  var getTag = baseGetTag;

  // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
  if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
      (Map && getTag(new Map) != mapTag) ||
      (Promise && getTag(Promise.resolve()) != promiseTag) ||
      (Set && getTag(new Set) != setTag) ||
      (WeakMap && getTag(new WeakMap) != weakMapTag)) {
    getTag = function(value) {
      var result = baseGetTag(value),
          Ctor = result == objectTag ? value.constructor : undefined,
          ctorString = Ctor ? toSource(Ctor) : '';

      if (ctorString) {
        switch (ctorString) {
          case dataViewCtorString: return dataViewTag;
          case mapCtorString: return mapTag;
          case promiseCtorString: return promiseTag;
          case setCtorString: return setTag;
          case weakMapCtorString: return weakMapTag;
        }
      }
      return result;
    };
  }

  /**
   * Gets the view, applying any `transforms` to the `start` and `end` positions.
   *
   * @private
   * @param {number} start The start of the view.
   * @param {number} end The end of the view.
   * @param {Array} transforms The transformations to apply to the view.
   * @returns {Object} Returns an object containing the `start` and `end`
   *  positions of the view.
   */
  function getView(start, end, transforms) {
    var index = -1,
        length = transforms.length;

    while (++index < length) {
      var data = transforms[index],
          size = data.size;

      switch (data.type) {
        case 'drop':      start += size; break;
        case 'dropRight': end -= size; break;
        case 'take':      end = nativeMin(end, start + size); break;
        case 'takeRight': start = nativeMax(start, end - size); break;
      }
    }
    return { 'start': start, 'end': end };
  }

  /**
   * Extracts wrapper details from the `source` body comment.
   *
   * @private
   * @param {string} source The source to inspect.
   * @returns {Array} Returns the wrapper details.
   */
  function getWrapDetails(source) {
    var match = source.match(reWrapDetails);
    return match ? match[1].split(reSplitDetails) : [];
  }

  /**
   * Checks if `path` exists on `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Array|string} path The path to check.
   * @param {Function} hasFunc The function to check properties.
   * @returns {boolean} Returns `true` if `path` exists, else `false`.
   */
  function hasPath(object, path, hasFunc) {
    path = castPath(path, object);

    var index = -1,
        length = path.length,
        result = false;

    while (++index < length) {
      var key = toKey(path[index]);
      if (!(result = object != null && hasFunc(object, key))) {
        break;
      }
      object = object[key];
    }
    if (result || ++index != length) {
      return result;
    }
    length = object == null ? 0 : object.length;
    return !!length && isLength(length) && isIndex(key, length) &&
      (isArray(object) || isArguments(object));
  }

  /**
   * Initializes an array clone.
   *
   * @private
   * @param {Array} array The array to clone.
   * @returns {Array} Returns the initialized clone.
   */
  function initCloneArray(array) {
    var length = array.length,
        result = array.constructor(length);

    // Add properties assigned by `RegExp#exec`.
    if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
      result.index = array.index;
      result.input = array.input;
    }
    return result;
  }

  /**
   * Initializes an object clone.
   *
   * @private
   * @param {Object} object The object to clone.
   * @returns {Object} Returns the initialized clone.
   */
  function initCloneObject(object) {
    return (typeof object.constructor == 'function' && !isPrototype(object))
      ? baseCreate(getPrototype(object))
      : {};
  }

  /**
   * Initializes an object clone based on its `toStringTag`.
   *
   * **Note:** This function only supports cloning values with tags of
   * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
   *
   * @private
   * @param {Object} object The object to clone.
   * @param {string} tag The `toStringTag` of the object to clone.
   * @param {Function} cloneFunc The function to clone values.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Object} Returns the initialized clone.
   */
  function initCloneByTag(object, tag, cloneFunc, isDeep) {
    var Ctor = object.constructor;
    switch (tag) {
      case arrayBufferTag:
        return cloneArrayBuffer(object);

      case boolTag:
      case dateTag:
        return new Ctor(+object);

      case dataViewTag:
        return cloneDataView(object, isDeep);

      case float32Tag: case float64Tag:
      case int8Tag: case int16Tag: case int32Tag:
      case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
        return cloneTypedArray(object, isDeep);

      case mapTag:
        return cloneMap(object, isDeep, cloneFunc);

      case numberTag:
      case stringTag:
        return new Ctor(object);

      case regexpTag:
        return cloneRegExp(object);

      case setTag:
        return cloneSet(object, isDeep, cloneFunc);

      case symbolTag:
        return cloneSymbol(object);
    }
  }

  /**
   * Inserts wrapper `details` in a comment at the top of the `source` body.
   *
   * @private
   * @param {string} source The source to modify.
   * @returns {Array} details The details to insert.
   * @returns {string} Returns the modified source.
   */
  function insertWrapDetails(source, details) {
    var length = details.length;
    if (!length) {
      return source;
    }
    var lastIndex = length - 1;
    details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];
    details = details.join(length > 2 ? ', ' : ' ');
    return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n');
  }

  /**
   * Checks if `value` is a flattenable `arguments` object or array.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
   */
  function isFlattenable(value) {
    return isArray(value) || isArguments(value) ||
      !!(spreadableSymbol && value && value[spreadableSymbol]);
  }

  /**
   * Checks if `value` is a valid array-like index.
   *
   * @private
   * @param {*} value The value to check.
   * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
   * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
   */
  function isIndex(value, length) {
    length = length == null ? MAX_SAFE_INTEGER : length;
    return !!length &&
      (typeof value == 'number' || reIsUint.test(value)) &&
      (value > -1 && value % 1 == 0 && value < length);
  }

  /**
   * Checks if the given arguments are from an iteratee call.
   *
   * @private
   * @param {*} value The potential iteratee value argument.
   * @param {*} index The potential iteratee index or key argument.
   * @param {*} object The potential iteratee object argument.
   * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
   *  else `false`.
   */
  function isIterateeCall(value, index, object) {
    if (!isObject(object)) {
      return false;
    }
    var type = typeof index;
    if (type == 'number'
          ? (isArrayLike(object) && isIndex(index, object.length))
          : (type == 'string' && index in object)
        ) {
      return eq(object[index], value);
    }
    return false;
  }

  /**
   * Checks if `value` is a property name and not a property path.
   *
   * @private
   * @param {*} value The value to check.
   * @param {Object} [object] The object to query keys on.
   * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
   */
  function isKey(value, object) {
    if (isArray(value)) {
      return false;
    }
    var type = typeof value;
    if (type == 'number' || type == 'symbol' || type == 'boolean' ||
        value == null || isSymbol(value)) {
      return true;
    }
    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
      (object != null && value in Object(object));
  }

  /**
   * Checks if `value` is suitable for use as unique object key.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
   */
  function isKeyable(value) {
    var type = typeof value;
    return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
      ? (value !== '__proto__')
      : (value === null);
  }

  /**
   * Checks if `func` has a lazy counterpart.
   *
   * @private
   * @param {Function} func The function to check.
   * @returns {boolean} Returns `true` if `func` has a lazy counterpart,
   *  else `false`.
   */
  function isLaziable(func) {
    var funcName = getFuncName(func),
        other = lodash[funcName];

    if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {
      return false;
    }
    if (func === other) {
      return true;
    }
    var data = getData(other);
    return !!data && func === data[0];
  }

  /**
   * Checks if `func` has its source masked.
   *
   * @private
   * @param {Function} func The function to check.
   * @returns {boolean} Returns `true` if `func` is masked, else `false`.
   */
  function isMasked(func) {
    return !!maskSrcKey && (maskSrcKey in func);
  }

  /**
   * Checks if `func` is capable of being masked.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `func` is maskable, else `false`.
   */
  var isMaskable = coreJsData ? isFunction : stubFalse;

  /**
   * Checks if `value` is likely a prototype object.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
   */
  function isPrototype(value) {
    var Ctor = value && value.constructor,
        proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;

    return value === proto;
  }

  /**
   * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` if suitable for strict
   *  equality comparisons, else `false`.
   */
  function isStrictComparable(value) {
    return value === value && !isObject(value);
  }

  /**
   * A specialized version of `matchesProperty` for source values suitable
   * for strict equality comparisons, i.e. `===`.
   *
   * @private
   * @param {string} key The key of the property to get.
   * @param {*} srcValue The value to match.
   * @returns {Function} Returns the new spec function.
   */
  function matchesStrictComparable(key, srcValue) {
    return function(object) {
      if (object == null) {
        return false;
      }
      return object[key] === srcValue &&
        (srcValue !== undefined || (key in Object(object)));
    };
  }

  /**
   * A specialized version of `_.memoize` which clears the memoized function's
   * cache when it exceeds `MAX_MEMOIZE_SIZE`.
   *
   * @private
   * @param {Function} func The function to have its output memoized.
   * @returns {Function} Returns the new memoized function.
   */
  function memoizeCapped(func) {
    var result = memoize(func, function(key) {
      if (cache.size === MAX_MEMOIZE_SIZE) {
        cache.clear();
      }
      return key;
    });

    var cache = result.cache;
    return result;
  }

  /**
   * Merges the function metadata of `source` into `data`.
   *
   * Merging metadata reduces the number of wrappers used to invoke a function.
   * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`
   * may be applied regardless of execution order. Methods like `_.ary` and
   * `_.rearg` modify function arguments, making the order in which they are
   * executed important, preventing the merging of metadata. However, we make
   * an exception for a safe combined case where curried functions have `_.ary`
   * and or `_.rearg` applied.
   *
   * @private
   * @param {Array} data The destination metadata.
   * @param {Array} source The source metadata.
   * @returns {Array} Returns `data`.
   */
  function mergeData(data, source) {
    var bitmask = data[1],
        srcBitmask = source[1],
        newBitmask = bitmask | srcBitmask,
        isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);

    var isCombo =
      ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||
      ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||
      ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));

    // Exit early if metadata can't be merged.
    if (!(isCommon || isCombo)) {
      return data;
    }
    // Use source `thisArg` if available.
    if (srcBitmask & WRAP_BIND_FLAG) {
      data[2] = source[2];
      // Set when currying a bound function.
      newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
    }
    // Compose partial arguments.
    var value = source[3];
    if (value) {
      var partials = data[3];
      data[3] = partials ? composeArgs(partials, value, source[4]) : value;
      data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
    }
    // Compose partial right arguments.
    value = source[5];
    if (value) {
      partials = data[5];
      data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
      data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
    }
    // Use source `argPos` if available.
    value = source[7];
    if (value) {
      data[7] = value;
    }
    // Use source `ary` if it's smaller.
    if (srcBitmask & WRAP_ARY_FLAG) {
      data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
    }
    // Use source `arity` if one is not provided.
    if (data[9] == null) {
      data[9] = source[9];
    }
    // Use source `func` and merge bitmasks.
    data[0] = source[0];
    data[1] = newBitmask;

    return data;
  }

  /**
   * This function is like
   * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
   * except that it includes inherited enumerable properties.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   */
  function nativeKeysIn(object) {
    var result = [];
    if (object != null) {
      for (var key in Object(object)) {
        result.push(key);
      }
    }
    return result;
  }

  /**
   * Converts `value` to a string using `Object.prototype.toString`.
   *
   * @private
   * @param {*} value The value to convert.
   * @returns {string} Returns the converted string.
   */
  function objectToString(value) {
    return nativeObjectToString.call(value);
  }

  /**
   * A specialized version of `baseRest` which transforms the rest array.
   *
   * @private
   * @param {Function} func The function to apply a rest parameter to.
   * @param {number} [start=func.length-1] The start position of the rest parameter.
   * @param {Function} transform The rest array transform.
   * @returns {Function} Returns the new function.
   */
  function overRest(func, start, transform) {
    start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
    return function() {
      var args = arguments,
          index = -1,
          length = nativeMax(args.length - start, 0),
          array = Array(length);

      while (++index < length) {
        array[index] = args[start + index];
      }
      index = -1;
      var otherArgs = Array(start + 1);
      while (++index < start) {
        otherArgs[index] = args[index];
      }
      otherArgs[start] = transform(array);
      return apply(func, this, otherArgs);
    };
  }

  /**
   * Gets the parent value at `path` of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Array} path The path to get the parent value of.
   * @returns {*} Returns the parent value.
   */
  function parent(object, path) {
    return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
  }

  /**
   * Reorder `array` according to the specified indexes where the element at
   * the first index is assigned as the first element, the element at
   * the second index is assigned as the second element, and so on.
   *
   * @private
   * @param {Array} array The array to reorder.
   * @param {Array} indexes The arranged array indexes.
   * @returns {Array} Returns `array`.
   */
  function reorder(array, indexes) {
    var arrLength = array.length,
        length = nativeMin(indexes.length, arrLength),
        oldArray = copyArray(array);

    while (length--) {
      var index = indexes[length];
      array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;
    }
    return array;
  }

  /**
   * Sets metadata for `func`.
   *
   * **Note:** If this function becomes hot, i.e. is invoked a lot in a short
   * period of time, it will trip its breaker and transition to an identity
   * function to avoid garbage collection pauses in V8. See
   * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)
   * for more details.
   *
   * @private
   * @param {Function} func The function to associate metadata with.
   * @param {*} data The metadata.
   * @returns {Function} Returns `func`.
   */
  var setData = shortOut(baseSetData);

  /**
   * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).
   *
   * @private
   * @param {Function} func The function to delay.
   * @param {number} wait The number of milliseconds to delay invocation.
   * @returns {number|Object} Returns the timer id or timeout object.
   */
  var setTimeout = ctxSetTimeout || function(func, wait) {
    return root.setTimeout(func, wait);
  };

  /**
   * Sets the `toString` method of `func` to return `string`.
   *
   * @private
   * @param {Function} func The function to modify.
   * @param {Function} string The `toString` result.
   * @returns {Function} Returns `func`.
   */
  var setToString = shortOut(baseSetToString);

  /**
   * Sets the `toString` method of `wrapper` to mimic the source of `reference`
   * with wrapper details in a comment at the top of the source body.
   *
   * @private
   * @param {Function} wrapper The function to modify.
   * @param {Function} reference The reference function.
   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
   * @returns {Function} Returns `wrapper`.
   */
  function setWrapToString(wrapper, reference, bitmask) {
    var source = (reference + '');
    return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
  }

  /**
   * Creates a function that'll short out and invoke `identity` instead
   * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
   * milliseconds.
   *
   * @private
   * @param {Function} func The function to restrict.
   * @returns {Function} Returns the new shortable function.
   */
  function shortOut(func) {
    var count = 0,
        lastCalled = 0;

    return function() {
      var stamp = nativeNow(),
          remaining = HOT_SPAN - (stamp - lastCalled);

      lastCalled = stamp;
      if (remaining > 0) {
        if (++count >= HOT_COUNT) {
          return arguments[0];
        }
      } else {
        count = 0;
      }
      return func.apply(undefined, arguments);
    };
  }

  /**
   * A specialized version of `_.shuffle` which mutates and sets the size of `array`.
   *
   * @private
   * @param {Array} array The array to shuffle.
   * @param {number} [size=array.length] The size of `array`.
   * @returns {Array} Returns `array`.
   */
  function shuffleSelf(array, size) {
    var index = -1,
        length = array.length,
        lastIndex = length - 1;

    size = size === undefined ? length : size;
    while (++index < size) {
      var rand = baseRandom(index, lastIndex),
          value = array[rand];

      array[rand] = array[index];
      array[index] = value;
    }
    array.length = size;
    return array;
  }

  /**
   * Converts `string` to a property path array.
   *
   * @private
   * @param {string} string The string to convert.
   * @returns {Array} Returns the property path array.
   */
  var stringToPath = memoizeCapped(function(string) {
    var result = [];
    if (reLeadingDot.test(string)) {
      result.push('');
    }
    string.replace(rePropName, function(match, number, quote, string) {
      result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
    });
    return result;
  });

  /**
   * Converts `value` to a string key if it's not a string or symbol.
   *
   * @private
   * @param {*} value The value to inspect.
   * @returns {string|symbol} Returns the key.
   */
  function toKey(value) {
    if (typeof value == 'string' || isSymbol(value)) {
      return value;
    }
    var result = (value + '');
    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
  }

  /**
   * Converts `func` to its source code.
   *
   * @private
   * @param {Function} func The function to convert.
   * @returns {string} Returns the source code.
   */
  function toSource(func) {
    if (func != null) {
      try {
        return funcToString.call(func);
      } catch (e) {}
      try {
        return (func + '');
      } catch (e) {}
    }
    return '';
  }

  /**
   * Updates wrapper `details` based on `bitmask` flags.
   *
   * @private
   * @returns {Array} details The details to modify.
   * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
   * @returns {Array} Returns `details`.
   */
  function updateWrapDetails(details, bitmask) {
    arrayEach(wrapFlags, function(pair) {
      var value = '_.' + pair[0];
      if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {
        details.push(value);
      }
    });
    return details.sort();
  }

  /**
   * Creates a clone of `wrapper`.
   *
   * @private
   * @param {Object} wrapper The wrapper to clone.
   * @returns {Object} Returns the cloned wrapper.
   */
  function wrapperClone(wrapper) {
    if (wrapper instanceof LazyWrapper) {
      return wrapper.clone();
    }
    var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
    result.__actions__ = copyArray(wrapper.__actions__);
    result.__index__  = wrapper.__index__;
    result.__values__ = wrapper.__values__;
    return result;
  }

  /*------------------------------------------------------------------------*/

  /**
   * Creates an array of elements split into groups the length of `size`.
   * If `array` can't be split evenly, the final chunk will be the remaining
   * elements.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Array
   * @param {Array} array The array to process.
   * @param {number} [size=1] The length of each chunk
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {Array} Returns the new array of chunks.
   * @example
   *
   * _.chunk(['a', 'b', 'c', 'd'], 2);
   * // => [['a', 'b'], ['c', 'd']]
   *
   * _.chunk(['a', 'b', 'c', 'd'], 3);
   * // => [['a', 'b', 'c'], ['d']]
   */
  function chunk(array, size, guard) {
    if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {
      size = 1;
    } else {
      size = nativeMax(toInteger(size), 0);
    }
    var length = array == null ? 0 : array.length;
    if (!length || size < 1) {
      return [];
    }
    var index = 0,
        resIndex = 0,
        result = Array(nativeCeil(length / size));

    while (index < length) {
      result[resIndex++] = baseSlice(array, index, (index += size));
    }
    return result;
  }

  /**
   * Creates an array with all falsey values removed. The values `false`, `null`,
   * `0`, `""`, `undefined`, and `NaN` are falsey.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The array to compact.
   * @returns {Array} Returns the new array of filtered values.
   * @example
   *
   * _.compact([0, 1, false, 2, '', 3]);
   * // => [1, 2, 3]
   */
  function compact(array) {
    var index = -1,
        length = array == null ? 0 : array.length,
        resIndex = 0,
        result = [];

    while (++index < length) {
      var value = array[index];
      if (value) {
        result[resIndex++] = value;
      }
    }
    return result;
  }

  /**
   * Creates a new array concatenating `array` with any additional arrays
   * and/or values.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The array to concatenate.
   * @param {...*} [values] The values to concatenate.
   * @returns {Array} Returns the new concatenated array.
   * @example
   *
   * var array = [1];
   * var other = _.concat(array, 2, [3], [[4]]);
   *
   * console.log(other);
   * // => [1, 2, 3, [4]]
   *
   * console.log(array);
   * // => [1]
   */
  function concat() {
    var length = arguments.length;
    if (!length) {
      return [];
    }
    var args = Array(length - 1),
        array = arguments[0],
        index = length;

    while (index--) {
      args[index - 1] = arguments[index];
    }
    return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));
  }

  /**
   * Creates an array of `array` values not included in the other given arrays
   * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * for equality comparisons. The order and references of result values are
   * determined by the first array.
   *
   * **Note:** Unlike `_.pullAll`, this method returns a new array.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @param {...Array} [values] The values to exclude.
   * @returns {Array} Returns the new array of filtered values.
   * @see _.without, _.xor
   * @example
   *
   * _.difference([2, 1], [2, 3]);
   * // => [1]
   */
  var difference = baseRest(function(array, values) {
    return isArrayLikeObject(array)
      ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))
      : [];
  });

  /**
   * This method is like `_.difference` except that it accepts `iteratee` which
   * is invoked for each element of `array` and `values` to generate the criterion
   * by which they're compared. The order and references of result values are
   * determined by the first array. The iteratee is invoked with one argument:
   * (value).
   *
   * **Note:** Unlike `_.pullAllBy`, this method returns a new array.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @param {...Array} [values] The values to exclude.
   * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
   * @returns {Array} Returns the new array of filtered values.
   * @example
   *
   * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
   * // => [1.2]
   *
   * // The `_.property` iteratee shorthand.
   * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
   * // => [{ 'x': 2 }]
   */
  var differenceBy = baseRest(function(array, values) {
    var iteratee = last(values);
    if (isArrayLikeObject(iteratee)) {
      iteratee = undefined;
    }
    return isArrayLikeObject(array)
      ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))
      : [];
  });

  /**
   * This method is like `_.difference` except that it accepts `comparator`
   * which is invoked to compare elements of `array` to `values`. The order and
   * references of result values are determined by the first array. The comparator
   * is invoked with two arguments: (arrVal, othVal).
   *
   * **Note:** Unlike `_.pullAllWith`, this method returns a new array.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @param {...Array} [values] The values to exclude.
   * @param {Function} [comparator] The comparator invoked per element.
   * @returns {Array} Returns the new array of filtered values.
   * @example
   *
   * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
   *
   * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);
   * // => [{ 'x': 2, 'y': 1 }]
   */
  var differenceWith = baseRest(function(array, values) {
    var comparator = last(values);
    if (isArrayLikeObject(comparator)) {
      comparator = undefined;
    }
    return isArrayLikeObject(array)
      ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)
      : [];
  });

  /**
   * Creates a slice of `array` with `n` elements dropped from the beginning.
   *
   * @static
   * @memberOf _
   * @since 0.5.0
   * @category Array
   * @param {Array} array The array to query.
   * @param {number} [n=1] The number of elements to drop.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {Array} Returns the slice of `array`.
   * @example
   *
   * _.drop([1, 2, 3]);
   * // => [2, 3]
   *
   * _.drop([1, 2, 3], 2);
   * // => [3]
   *
   * _.drop([1, 2, 3], 5);
   * // => []
   *
   * _.drop([1, 2, 3], 0);
   * // => [1, 2, 3]
   */
  function drop(array, n, guard) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return [];
    }
    n = (guard || n === undefined) ? 1 : toInteger(n);
    return baseSlice(array, n < 0 ? 0 : n, length);
  }

  /**
   * Creates a slice of `array` with `n` elements dropped from the end.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Array
   * @param {Array} array The array to query.
   * @param {number} [n=1] The number of elements to drop.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {Array} Returns the slice of `array`.
   * @example
   *
   * _.dropRight([1, 2, 3]);
   * // => [1, 2]
   *
   * _.dropRight([1, 2, 3], 2);
   * // => [1]
   *
   * _.dropRight([1, 2, 3], 5);
   * // => []
   *
   * _.dropRight([1, 2, 3], 0);
   * // => [1, 2, 3]
   */
  function dropRight(array, n, guard) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return [];
    }
    n = (guard || n === undefined) ? 1 : toInteger(n);
    n = length - n;
    return baseSlice(array, 0, n < 0 ? 0 : n);
  }

  /**
   * Creates a slice of `array` excluding elements dropped from the end.
   * Elements are dropped until `predicate` returns falsey. The predicate is
   * invoked with three arguments: (value, index, array).
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Array
   * @param {Array} array The array to query.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @returns {Array} Returns the slice of `array`.
   * @example
   *
   * var users = [
   *   { 'user': 'barney',  'active': true },
   *   { 'user': 'fred',    'active': false },
   *   { 'user': 'pebbles', 'active': false }
   * ];
   *
   * _.dropRightWhile(users, function(o) { return !o.active; });
   * // => objects for ['barney']
   *
   * // The `_.matches` iteratee shorthand.
   * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
   * // => objects for ['barney', 'fred']
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.dropRightWhile(users, ['active', false]);
   * // => objects for ['barney']
   *
   * // The `_.property` iteratee shorthand.
   * _.dropRightWhile(users, 'active');
   * // => objects for ['barney', 'fred', 'pebbles']
   */
  function dropRightWhile(array, predicate) {
    return (array && array.length)
      ? baseWhile(array, getIteratee(predicate, 3), true, true)
      : [];
  }

  /**
   * Creates a slice of `array` excluding elements dropped from the beginning.
   * Elements are dropped until `predicate` returns falsey. The predicate is
   * invoked with three arguments: (value, index, array).
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Array
   * @param {Array} array The array to query.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @returns {Array} Returns the slice of `array`.
   * @example
   *
   * var users = [
   *   { 'user': 'barney',  'active': false },
   *   { 'user': 'fred',    'active': false },
   *   { 'user': 'pebbles', 'active': true }
   * ];
   *
   * _.dropWhile(users, function(o) { return !o.active; });
   * // => objects for ['pebbles']
   *
   * // The `_.matches` iteratee shorthand.
   * _.dropWhile(users, { 'user': 'barney', 'active': false });
   * // => objects for ['fred', 'pebbles']
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.dropWhile(users, ['active', false]);
   * // => objects for ['pebbles']
   *
   * // The `_.property` iteratee shorthand.
   * _.dropWhile(users, 'active');
   * // => objects for ['barney', 'fred', 'pebbles']
   */
  function dropWhile(array, predicate) {
    return (array && array.length)
      ? baseWhile(array, getIteratee(predicate, 3), true)
      : [];
  }

  /**
   * Fills elements of `array` with `value` from `start` up to, but not
   * including, `end`.
   *
   * **Note:** This method mutates `array`.
   *
   * @static
   * @memberOf _
   * @since 3.2.0
   * @category Array
   * @param {Array} array The array to fill.
   * @param {*} value The value to fill `array` with.
   * @param {number} [start=0] The start position.
   * @param {number} [end=array.length] The end position.
   * @returns {Array} Returns `array`.
   * @example
   *
   * var array = [1, 2, 3];
   *
   * _.fill(array, 'a');
   * console.log(array);
   * // => ['a', 'a', 'a']
   *
   * _.fill(Array(3), 2);
   * // => [2, 2, 2]
   *
   * _.fill([4, 6, 8, 10], '*', 1, 3);
   * // => [4, '*', '*', 10]
   */
  function fill(array, value, start, end) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return [];
    }
    if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {
      start = 0;
      end = length;
    }
    return baseFill(array, value, start, end);
  }

  /**
   * This method is like `_.find` except that it returns the index of the first
   * element `predicate` returns truthy for instead of the element itself.
   *
   * @static
   * @memberOf _
   * @since 1.1.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @param {number} [fromIndex=0] The index to search from.
   * @returns {number} Returns the index of the found element, else `-1`.
   * @example
   *
   * var users = [
   *   { 'user': 'barney',  'active': false },
   *   { 'user': 'fred',    'active': false },
   *   { 'user': 'pebbles', 'active': true }
   * ];
   *
   * _.findIndex(users, function(o) { return o.user == 'barney'; });
   * // => 0
   *
   * // The `_.matches` iteratee shorthand.
   * _.findIndex(users, { 'user': 'fred', 'active': false });
   * // => 1
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.findIndex(users, ['active', false]);
   * // => 0
   *
   * // The `_.property` iteratee shorthand.
   * _.findIndex(users, 'active');
   * // => 2
   */
  function findIndex(array, predicate, fromIndex) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return -1;
    }
    var index = fromIndex == null ? 0 : toInteger(fromIndex);
    if (index < 0) {
      index = nativeMax(length + index, 0);
    }
    return baseFindIndex(array, getIteratee(predicate, 3), index);
  }

  /**
   * This method is like `_.findIndex` except that it iterates over elements
   * of `collection` from right to left.
   *
   * @static
   * @memberOf _
   * @since 2.0.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @param {number} [fromIndex=array.length-1] The index to search from.
   * @returns {number} Returns the index of the found element, else `-1`.
   * @example
   *
   * var users = [
   *   { 'user': 'barney',  'active': true },
   *   { 'user': 'fred',    'active': false },
   *   { 'user': 'pebbles', 'active': false }
   * ];
   *
   * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
   * // => 2
   *
   * // The `_.matches` iteratee shorthand.
   * _.findLastIndex(users, { 'user': 'barney', 'active': true });
   * // => 0
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.findLastIndex(users, ['active', false]);
   * // => 2
   *
   * // The `_.property` iteratee shorthand.
   * _.findLastIndex(users, 'active');
   * // => 0
   */
  function findLastIndex(array, predicate, fromIndex) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return -1;
    }
    var index = length - 1;
    if (fromIndex !== undefined) {
      index = toInteger(fromIndex);
      index = fromIndex < 0
        ? nativeMax(length + index, 0)
        : nativeMin(index, length - 1);
    }
    return baseFindIndex(array, getIteratee(predicate, 3), index, true);
  }

  /**
   * Flattens `array` a single level deep.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The array to flatten.
   * @returns {Array} Returns the new flattened array.
   * @example
   *
   * _.flatten([1, [2, [3, [4]], 5]]);
   * // => [1, 2, [3, [4]], 5]
   */
  function flatten(array) {
    var length = array == null ? 0 : array.length;
    return length ? baseFlatten(array, 1) : [];
  }

  /**
   * Recursively flattens `array`.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Array
   * @param {Array} array The array to flatten.
   * @returns {Array} Returns the new flattened array.
   * @example
   *
   * _.flattenDeep([1, [2, [3, [4]], 5]]);
   * // => [1, 2, 3, 4, 5]
   */
  function flattenDeep(array) {
    var length = array == null ? 0 : array.length;
    return length ? baseFlatten(array, INFINITY) : [];
  }

  /**
   * Recursively flatten `array` up to `depth` times.
   *
   * @static
   * @memberOf _
   * @since 4.4.0
   * @category Array
   * @param {Array} array The array to flatten.
   * @param {number} [depth=1] The maximum recursion depth.
   * @returns {Array} Returns the new flattened array.
   * @example
   *
   * var array = [1, [2, [3, [4]], 5]];
   *
   * _.flattenDepth(array, 1);
   * // => [1, 2, [3, [4]], 5]
   *
   * _.flattenDepth(array, 2);
   * // => [1, 2, 3, [4], 5]
   */
  function flattenDepth(array, depth) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return [];
    }
    depth = depth === undefined ? 1 : toInteger(depth);
    return baseFlatten(array, depth);
  }

  /**
   * The inverse of `_.toPairs`; this method returns an object composed
   * from key-value `pairs`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} pairs The key-value pairs.
   * @returns {Object} Returns the new object.
   * @example
   *
   * _.fromPairs([['a', 1], ['b', 2]]);
   * // => { 'a': 1, 'b': 2 }
   */
  function fromPairs(pairs) {
    var index = -1,
        length = pairs == null ? 0 : pairs.length,
        result = {};

    while (++index < length) {
      var pair = pairs[index];
      result[pair[0]] = pair[1];
    }
    return result;
  }

  /**
   * Gets the first element of `array`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @alias first
   * @category Array
   * @param {Array} array The array to query.
   * @returns {*} Returns the first element of `array`.
   * @example
   *
   * _.head([1, 2, 3]);
   * // => 1
   *
   * _.head([]);
   * // => undefined
   */
  function head(array) {
    return (array && array.length) ? array[0] : undefined;
  }

  /**
   * Gets the index at which the first occurrence of `value` is found in `array`
   * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * for equality comparisons. If `fromIndex` is negative, it's used as the
   * offset from the end of `array`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @param {number} [fromIndex=0] The index to search from.
   * @returns {number} Returns the index of the matched value, else `-1`.
   * @example
   *
   * _.indexOf([1, 2, 1, 2], 2);
   * // => 1
   *
   * // Search from the `fromIndex`.
   * _.indexOf([1, 2, 1, 2], 2, 2);
   * // => 3
   */
  function indexOf(array, value, fromIndex) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return -1;
    }
    var index = fromIndex == null ? 0 : toInteger(fromIndex);
    if (index < 0) {
      index = nativeMax(length + index, 0);
    }
    return baseIndexOf(array, value, index);
  }

  /**
   * Gets all but the last element of `array`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The array to query.
   * @returns {Array} Returns the slice of `array`.
   * @example
   *
   * _.initial([1, 2, 3]);
   * // => [1, 2]
   */
  function initial(array) {
    var length = array == null ? 0 : array.length;
    return length ? baseSlice(array, 0, -1) : [];
  }

  /**
   * Creates an array of unique values that are included in all given arrays
   * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * for equality comparisons. The order and references of result values are
   * determined by the first array.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {...Array} [arrays] The arrays to inspect.
   * @returns {Array} Returns the new array of intersecting values.
   * @example
   *
   * _.intersection([2, 1], [2, 3]);
   * // => [2]
   */
  var intersection = baseRest(function(arrays) {
    var mapped = arrayMap(arrays, castArrayLikeObject);
    return (mapped.length && mapped[0] === arrays[0])
      ? baseIntersection(mapped)
      : [];
  });

  /**
   * This method is like `_.intersection` except that it accepts `iteratee`
   * which is invoked for each element of each `arrays` to generate the criterion
   * by which they're compared. The order and references of result values are
   * determined by the first array. The iteratee is invoked with one argument:
   * (value).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {...Array} [arrays] The arrays to inspect.
   * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
   * @returns {Array} Returns the new array of intersecting values.
   * @example
   *
   * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
   * // => [2.1]
   *
   * // The `_.property` iteratee shorthand.
   * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
   * // => [{ 'x': 1 }]
   */
  var intersectionBy = baseRest(function(arrays) {
    var iteratee = last(arrays),
        mapped = arrayMap(arrays, castArrayLikeObject);

    if (iteratee === last(mapped)) {
      iteratee = undefined;
    } else {
      mapped.pop();
    }
    return (mapped.length && mapped[0] === arrays[0])
      ? baseIntersection(mapped, getIteratee(iteratee, 2))
      : [];
  });

  /**
   * This method is like `_.intersection` except that it accepts `comparator`
   * which is invoked to compare elements of `arrays`. The order and references
   * of result values are determined by the first array. The comparator is
   * invoked with two arguments: (arrVal, othVal).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {...Array} [arrays] The arrays to inspect.
   * @param {Function} [comparator] The comparator invoked per element.
   * @returns {Array} Returns the new array of intersecting values.
   * @example
   *
   * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
   * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
   *
   * _.intersectionWith(objects, others, _.isEqual);
   * // => [{ 'x': 1, 'y': 2 }]
   */
  var intersectionWith = baseRest(function(arrays) {
    var comparator = last(arrays),
        mapped = arrayMap(arrays, castArrayLikeObject);

    comparator = typeof comparator == 'function' ? comparator : undefined;
    if (comparator) {
      mapped.pop();
    }
    return (mapped.length && mapped[0] === arrays[0])
      ? baseIntersection(mapped, undefined, comparator)
      : [];
  });

  /**
   * Converts all elements in `array` into a string separated by `separator`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The array to convert.
   * @param {string} [separator=','] The element separator.
   * @returns {string} Returns the joined string.
   * @example
   *
   * _.join(['a', 'b', 'c'], '~');
   * // => 'a~b~c'
   */
  function join(array, separator) {
    return array == null ? '' : nativeJoin.call(array, separator);
  }

  /**
   * Gets the last element of `array`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The array to query.
   * @returns {*} Returns the last element of `array`.
   * @example
   *
   * _.last([1, 2, 3]);
   * // => 3
   */
  function last(array) {
    var length = array == null ? 0 : array.length;
    return length ? array[length - 1] : undefined;
  }

  /**
   * This method is like `_.indexOf` except that it iterates over elements of
   * `array` from right to left.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @param {number} [fromIndex=array.length-1] The index to search from.
   * @returns {number} Returns the index of the matched value, else `-1`.
   * @example
   *
   * _.lastIndexOf([1, 2, 1, 2], 2);
   * // => 3
   *
   * // Search from the `fromIndex`.
   * _.lastIndexOf([1, 2, 1, 2], 2, 2);
   * // => 1
   */
  function lastIndexOf(array, value, fromIndex) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return -1;
    }
    var index = length;
    if (fromIndex !== undefined) {
      index = toInteger(fromIndex);
      index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
    }
    return value === value
      ? strictLastIndexOf(array, value, index)
      : baseFindIndex(array, baseIsNaN, index, true);
  }

  /**
   * Gets the element at index `n` of `array`. If `n` is negative, the nth
   * element from the end is returned.
   *
   * @static
   * @memberOf _
   * @since 4.11.0
   * @category Array
   * @param {Array} array The array to query.
   * @param {number} [n=0] The index of the element to return.
   * @returns {*} Returns the nth element of `array`.
   * @example
   *
   * var array = ['a', 'b', 'c', 'd'];
   *
   * _.nth(array, 1);
   * // => 'b'
   *
   * _.nth(array, -2);
   * // => 'c';
   */
  function nth(array, n) {
    return (array && array.length) ? baseNth(array, toInteger(n)) : undefined;
  }

  /**
   * Removes all given values from `array` using
   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * for equality comparisons.
   *
   * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`
   * to remove elements from an array by predicate.
   *
   * @static
   * @memberOf _
   * @since 2.0.0
   * @category Array
   * @param {Array} array The array to modify.
   * @param {...*} [values] The values to remove.
   * @returns {Array} Returns `array`.
   * @example
   *
   * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
   *
   * _.pull(array, 'a', 'c');
   * console.log(array);
   * // => ['b', 'b']
   */
  var pull = baseRest(pullAll);

  /**
   * This method is like `_.pull` except that it accepts an array of values to remove.
   *
   * **Note:** Unlike `_.difference`, this method mutates `array`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The array to modify.
   * @param {Array} values The values to remove.
   * @returns {Array} Returns `array`.
   * @example
   *
   * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
   *
   * _.pullAll(array, ['a', 'c']);
   * console.log(array);
   * // => ['b', 'b']
   */
  function pullAll(array, values) {
    return (array && array.length && values && values.length)
      ? basePullAll(array, values)
      : array;
  }

  /**
   * This method is like `_.pullAll` except that it accepts `iteratee` which is
   * invoked for each element of `array` and `values` to generate the criterion
   * by which they're compared. The iteratee is invoked with one argument: (value).
   *
   * **Note:** Unlike `_.differenceBy`, this method mutates `array`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The array to modify.
   * @param {Array} values The values to remove.
   * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
   * @returns {Array} Returns `array`.
   * @example
   *
   * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
   *
   * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
   * console.log(array);
   * // => [{ 'x': 2 }]
   */
  function pullAllBy(array, values, iteratee) {
    return (array && array.length && values && values.length)
      ? basePullAll(array, values, getIteratee(iteratee, 2))
      : array;
  }

  /**
   * This method is like `_.pullAll` except that it accepts `comparator` which
   * is invoked to compare elements of `array` to `values`. The comparator is
   * invoked with two arguments: (arrVal, othVal).
   *
   * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
   *
   * @static
   * @memberOf _
   * @since 4.6.0
   * @category Array
   * @param {Array} array The array to modify.
   * @param {Array} values The values to remove.
   * @param {Function} [comparator] The comparator invoked per element.
   * @returns {Array} Returns `array`.
   * @example
   *
   * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
   *
   * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
   * console.log(array);
   * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
   */
  function pullAllWith(array, values, comparator) {
    return (array && array.length && values && values.length)
      ? basePullAll(array, values, undefined, comparator)
      : array;
  }

  /**
   * Removes elements from `array` corresponding to `indexes` and returns an
   * array of removed elements.
   *
   * **Note:** Unlike `_.at`, this method mutates `array`.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Array
   * @param {Array} array The array to modify.
   * @param {...(number|number[])} [indexes] The indexes of elements to remove.
   * @returns {Array} Returns the new array of removed elements.
   * @example
   *
   * var array = ['a', 'b', 'c', 'd'];
   * var pulled = _.pullAt(array, [1, 3]);
   *
   * console.log(array);
   * // => ['a', 'c']
   *
   * console.log(pulled);
   * // => ['b', 'd']
   */
  var pullAt = flatRest(function(array, indexes) {
    var length = array == null ? 0 : array.length,
        result = baseAt(array, indexes);

    basePullAt(array, arrayMap(indexes, function(index) {
      return isIndex(index, length) ? +index : index;
    }).sort(compareAscending));

    return result;
  });

  /**
   * Removes all elements from `array` that `predicate` returns truthy for
   * and returns an array of the removed elements. The predicate is invoked
   * with three arguments: (value, index, array).
   *
   * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`
   * to pull elements from an array by value.
   *
   * @static
   * @memberOf _
   * @since 2.0.0
   * @category Array
   * @param {Array} array The array to modify.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @returns {Array} Returns the new array of removed elements.
   * @example
   *
   * var array = [1, 2, 3, 4];
   * var evens = _.remove(array, function(n) {
   *   return n % 2 == 0;
   * });
   *
   * console.log(array);
   * // => [1, 3]
   *
   * console.log(evens);
   * // => [2, 4]
   */
  function remove(array, predicate) {
    var result = [];
    if (!(array && array.length)) {
      return result;
    }
    var index = -1,
        indexes = [],
        length = array.length;

    predicate = getIteratee(predicate, 3);
    while (++index < length) {
      var value = array[index];
      if (predicate(value, index, array)) {
        result.push(value);
        indexes.push(index);
      }
    }
    basePullAt(array, indexes);
    return result;
  }

  /**
   * Reverses `array` so that the first element becomes the last, the second
   * element becomes the second to last, and so on.
   *
   * **Note:** This method mutates `array` and is based on
   * [`Array#reverse`](https://mdn.io/Array/reverse).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The array to modify.
   * @returns {Array} Returns `array`.
   * @example
   *
   * var array = [1, 2, 3];
   *
   * _.reverse(array);
   * // => [3, 2, 1]
   *
   * console.log(array);
   * // => [3, 2, 1]
   */
  function reverse(array) {
    return array == null ? array : nativeReverse.call(array);
  }

  /**
   * Creates a slice of `array` from `start` up to, but not including, `end`.
   *
   * **Note:** This method is used instead of
   * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
   * returned.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Array
   * @param {Array} array The array to slice.
   * @param {number} [start=0] The start position.
   * @param {number} [end=array.length] The end position.
   * @returns {Array} Returns the slice of `array`.
   */
  function slice(array, start, end) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return [];
    }
    if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {
      start = 0;
      end = length;
    }
    else {
      start = start == null ? 0 : toInteger(start);
      end = end === undefined ? length : toInteger(end);
    }
    return baseSlice(array, start, end);
  }

  /**
   * Uses a binary search to determine the lowest index at which `value`
   * should be inserted into `array` in order to maintain its sort order.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The sorted array to inspect.
   * @param {*} value The value to evaluate.
   * @returns {number} Returns the index at which `value` should be inserted
   *  into `array`.
   * @example
   *
   * _.sortedIndex([30, 50], 40);
   * // => 1
   */
  function sortedIndex(array, value) {
    return baseSortedIndex(array, value);
  }

  /**
   * This method is like `_.sortedIndex` except that it accepts `iteratee`
   * which is invoked for `value` and each element of `array` to compute their
   * sort ranking. The iteratee is invoked with one argument: (value).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The sorted array to inspect.
   * @param {*} value The value to evaluate.
   * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
   * @returns {number} Returns the index at which `value` should be inserted
   *  into `array`.
   * @example
   *
   * var objects = [{ 'x': 4 }, { 'x': 5 }];
   *
   * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
   * // => 0
   *
   * // The `_.property` iteratee shorthand.
   * _.sortedIndexBy(objects, { 'x': 4 }, 'x');
   * // => 0
   */
  function sortedIndexBy(array, value, iteratee) {
    return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));
  }

  /**
   * This method is like `_.indexOf` except that it performs a binary
   * search on a sorted `array`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @returns {number} Returns the index of the matched value, else `-1`.
   * @example
   *
   * _.sortedIndexOf([4, 5, 5, 5, 6], 5);
   * // => 1
   */
  function sortedIndexOf(array, value) {
    var length = array == null ? 0 : array.length;
    if (length) {
      var index = baseSortedIndex(array, value);
      if (index < length && eq(array[index], value)) {
        return index;
      }
    }
    return -1;
  }

  /**
   * This method is like `_.sortedIndex` except that it returns the highest
   * index at which `value` should be inserted into `array` in order to
   * maintain its sort order.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Array
   * @param {Array} array The sorted array to inspect.
   * @param {*} value The value to evaluate.
   * @returns {number} Returns the index at which `value` should be inserted
   *  into `array`.
   * @example
   *
   * _.sortedLastIndex([4, 5, 5, 5, 6], 5);
   * // => 4
   */
  function sortedLastIndex(array, value) {
    return baseSortedIndex(array, value, true);
  }

  /**
   * This method is like `_.sortedLastIndex` except that it accepts `iteratee`
   * which is invoked for `value` and each element of `array` to compute their
   * sort ranking. The iteratee is invoked with one argument: (value).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The sorted array to inspect.
   * @param {*} value The value to evaluate.
   * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
   * @returns {number} Returns the index at which `value` should be inserted
   *  into `array`.
   * @example
   *
   * var objects = [{ 'x': 4 }, { 'x': 5 }];
   *
   * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
   * // => 1
   *
   * // The `_.property` iteratee shorthand.
   * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
   * // => 1
   */
  function sortedLastIndexBy(array, value, iteratee) {
    return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);
  }

  /**
   * This method is like `_.lastIndexOf` except that it performs a binary
   * search on a sorted `array`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @returns {number} Returns the index of the matched value, else `-1`.
   * @example
   *
   * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
   * // => 3
   */
  function sortedLastIndexOf(array, value) {
    var length = array == null ? 0 : array.length;
    if (length) {
      var index = baseSortedIndex(array, value, true) - 1;
      if (eq(array[index], value)) {
        return index;
      }
    }
    return -1;
  }

  /**
   * This method is like `_.uniq` except that it's designed and optimized
   * for sorted arrays.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @returns {Array} Returns the new duplicate free array.
   * @example
   *
   * _.sortedUniq([1, 1, 2]);
   * // => [1, 2]
   */
  function sortedUniq(array) {
    return (array && array.length)
      ? baseSortedUniq(array)
      : [];
  }

  /**
   * This method is like `_.uniqBy` except that it's designed and optimized
   * for sorted arrays.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @param {Function} [iteratee] The iteratee invoked per element.
   * @returns {Array} Returns the new duplicate free array.
   * @example
   *
   * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
   * // => [1.1, 2.3]
   */
  function sortedUniqBy(array, iteratee) {
    return (array && array.length)
      ? baseSortedUniq(array, getIteratee(iteratee, 2))
      : [];
  }

  /**
   * Gets all but the first element of `array`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The array to query.
   * @returns {Array} Returns the slice of `array`.
   * @example
   *
   * _.tail([1, 2, 3]);
   * // => [2, 3]
   */
  function tail(array) {
    var length = array == null ? 0 : array.length;
    return length ? baseSlice(array, 1, length) : [];
  }

  /**
   * Creates a slice of `array` with `n` elements taken from the beginning.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The array to query.
   * @param {number} [n=1] The number of elements to take.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {Array} Returns the slice of `array`.
   * @example
   *
   * _.take([1, 2, 3]);
   * // => [1]
   *
   * _.take([1, 2, 3], 2);
   * // => [1, 2]
   *
   * _.take([1, 2, 3], 5);
   * // => [1, 2, 3]
   *
   * _.take([1, 2, 3], 0);
   * // => []
   */
  function take(array, n, guard) {
    if (!(array && array.length)) {
      return [];
    }
    n = (guard || n === undefined) ? 1 : toInteger(n);
    return baseSlice(array, 0, n < 0 ? 0 : n);
  }

  /**
   * Creates a slice of `array` with `n` elements taken from the end.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Array
   * @param {Array} array The array to query.
   * @param {number} [n=1] The number of elements to take.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {Array} Returns the slice of `array`.
   * @example
   *
   * _.takeRight([1, 2, 3]);
   * // => [3]
   *
   * _.takeRight([1, 2, 3], 2);
   * // => [2, 3]
   *
   * _.takeRight([1, 2, 3], 5);
   * // => [1, 2, 3]
   *
   * _.takeRight([1, 2, 3], 0);
   * // => []
   */
  function takeRight(array, n, guard) {
    var length = array == null ? 0 : array.length;
    if (!length) {
      return [];
    }
    n = (guard || n === undefined) ? 1 : toInteger(n);
    n = length - n;
    return baseSlice(array, n < 0 ? 0 : n, length);
  }

  /**
   * Creates a slice of `array` with elements taken from the end. Elements are
   * taken until `predicate` returns falsey. The predicate is invoked with
   * three arguments: (value, index, array).
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Array
   * @param {Array} array The array to query.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @returns {Array} Returns the slice of `array`.
   * @example
   *
   * var users = [
   *   { 'user': 'barney',  'active': true },
   *   { 'user': 'fred',    'active': false },
   *   { 'user': 'pebbles', 'active': false }
   * ];
   *
   * _.takeRightWhile(users, function(o) { return !o.active; });
   * // => objects for ['fred', 'pebbles']
   *
   * // The `_.matches` iteratee shorthand.
   * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
   * // => objects for ['pebbles']
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.takeRightWhile(users, ['active', false]);
   * // => objects for ['fred', 'pebbles']
   *
   * // The `_.property` iteratee shorthand.
   * _.takeRightWhile(users, 'active');
   * // => []
   */
  function takeRightWhile(array, predicate) {
    return (array && array.length)
      ? baseWhile(array, getIteratee(predicate, 3), false, true)
      : [];
  }

  /**
   * Creates a slice of `array` with elements taken from the beginning. Elements
   * are taken until `predicate` returns falsey. The predicate is invoked with
   * three arguments: (value, index, array).
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Array
   * @param {Array} array The array to query.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @returns {Array} Returns the slice of `array`.
   * @example
   *
   * var users = [
   *   { 'user': 'barney',  'active': false },
   *   { 'user': 'fred',    'active': false },
   *   { 'user': 'pebbles', 'active': true }
   * ];
   *
   * _.takeWhile(users, function(o) { return !o.active; });
   * // => objects for ['barney', 'fred']
   *
   * // The `_.matches` iteratee shorthand.
   * _.takeWhile(users, { 'user': 'barney', 'active': false });
   * // => objects for ['barney']
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.takeWhile(users, ['active', false]);
   * // => objects for ['barney', 'fred']
   *
   * // The `_.property` iteratee shorthand.
   * _.takeWhile(users, 'active');
   * // => []
   */
  function takeWhile(array, predicate) {
    return (array && array.length)
      ? baseWhile(array, getIteratee(predicate, 3))
      : [];
  }

  /**
   * Creates an array of unique values, in order, from all given arrays using
   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * for equality comparisons.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {...Array} [arrays] The arrays to inspect.
   * @returns {Array} Returns the new array of combined values.
   * @example
   *
   * _.union([2], [1, 2]);
   * // => [2, 1]
   */
  var union = baseRest(function(arrays) {
    return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
  });

  /**
   * This method is like `_.union` except that it accepts `iteratee` which is
   * invoked for each element of each `arrays` to generate the criterion by
   * which uniqueness is computed. Result values are chosen from the first
   * array in which the value occurs. The iteratee is invoked with one argument:
   * (value).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {...Array} [arrays] The arrays to inspect.
   * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
   * @returns {Array} Returns the new array of combined values.
   * @example
   *
   * _.unionBy([2.1], [1.2, 2.3], Math.floor);
   * // => [2.1, 1.2]
   *
   * // The `_.property` iteratee shorthand.
   * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
   * // => [{ 'x': 1 }, { 'x': 2 }]
   */
  var unionBy = baseRest(function(arrays) {
    var iteratee = last(arrays);
    if (isArrayLikeObject(iteratee)) {
      iteratee = undefined;
    }
    return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));
  });

  /**
   * This method is like `_.union` except that it accepts `comparator` which
   * is invoked to compare elements of `arrays`. Result values are chosen from
   * the first array in which the value occurs. The comparator is invoked
   * with two arguments: (arrVal, othVal).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {...Array} [arrays] The arrays to inspect.
   * @param {Function} [comparator] The comparator invoked per element.
   * @returns {Array} Returns the new array of combined values.
   * @example
   *
   * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
   * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
   *
   * _.unionWith(objects, others, _.isEqual);
   * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
   */
  var unionWith = baseRest(function(arrays) {
    var comparator = last(arrays);
    comparator = typeof comparator == 'function' ? comparator : undefined;
    return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);
  });

  /**
   * Creates a duplicate-free version of an array, using
   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * for equality comparisons, in which only the first occurrence of each element
   * is kept. The order of result values is determined by the order they occur
   * in the array.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @returns {Array} Returns the new duplicate free array.
   * @example
   *
   * _.uniq([2, 1, 2]);
   * // => [2, 1]
   */
  function uniq(array) {
    return (array && array.length) ? baseUniq(array) : [];
  }

  /**
   * This method is like `_.uniq` except that it accepts `iteratee` which is
   * invoked for each element in `array` to generate the criterion by which
   * uniqueness is computed. The order of result values is determined by the
   * order they occur in the array. The iteratee is invoked with one argument:
   * (value).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
   * @returns {Array} Returns the new duplicate free array.
   * @example
   *
   * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
   * // => [2.1, 1.2]
   *
   * // The `_.property` iteratee shorthand.
   * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
   * // => [{ 'x': 1 }, { 'x': 2 }]
   */
  function uniqBy(array, iteratee) {
    return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];
  }

  /**
   * This method is like `_.uniq` except that it accepts `comparator` which
   * is invoked to compare elements of `array`. The order of result values is
   * determined by the order they occur in the array.The comparator is invoked
   * with two arguments: (arrVal, othVal).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @param {Function} [comparator] The comparator invoked per element.
   * @returns {Array} Returns the new duplicate free array.
   * @example
   *
   * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
   *
   * _.uniqWith(objects, _.isEqual);
   * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
   */
  function uniqWith(array, comparator) {
    comparator = typeof comparator == 'function' ? comparator : undefined;
    return (array && array.length) ? baseUniq(array, undefined, comparator) : [];
  }

  /**
   * This method is like `_.zip` except that it accepts an array of grouped
   * elements and creates an array regrouping the elements to their pre-zip
   * configuration.
   *
   * @static
   * @memberOf _
   * @since 1.2.0
   * @category Array
   * @param {Array} array The array of grouped elements to process.
   * @returns {Array} Returns the new array of regrouped elements.
   * @example
   *
   * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
   * // => [['a', 1, true], ['b', 2, false]]
   *
   * _.unzip(zipped);
   * // => [['a', 'b'], [1, 2], [true, false]]
   */
  function unzip(array) {
    if (!(array && array.length)) {
      return [];
    }
    var length = 0;
    array = arrayFilter(array, function(group) {
      if (isArrayLikeObject(group)) {
        length = nativeMax(group.length, length);
        return true;
      }
    });
    return baseTimes(length, function(index) {
      return arrayMap(array, baseProperty(index));
    });
  }

  /**
   * This method is like `_.unzip` except that it accepts `iteratee` to specify
   * how regrouped values should be combined. The iteratee is invoked with the
   * elements of each group: (...group).
   *
   * @static
   * @memberOf _
   * @since 3.8.0
   * @category Array
   * @param {Array} array The array of grouped elements to process.
   * @param {Function} [iteratee=_.identity] The function to combine
   *  regrouped values.
   * @returns {Array} Returns the new array of regrouped elements.
   * @example
   *
   * var zipped = _.zip([1, 2], [10, 20], [100, 200]);
   * // => [[1, 10, 100], [2, 20, 200]]
   *
   * _.unzipWith(zipped, _.add);
   * // => [3, 30, 300]
   */
  function unzipWith(array, iteratee) {
    if (!(array && array.length)) {
      return [];
    }
    var result = unzip(array);
    if (iteratee == null) {
      return result;
    }
    return arrayMap(result, function(group) {
      return apply(iteratee, undefined, group);
    });
  }

  /**
   * Creates an array excluding all given values using
   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * for equality comparisons.
   *
   * **Note:** Unlike `_.pull`, this method returns a new array.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @param {...*} [values] The values to exclude.
   * @returns {Array} Returns the new array of filtered values.
   * @see _.difference, _.xor
   * @example
   *
   * _.without([2, 1, 2, 3], 1, 2);
   * // => [3]
   */
  var without = baseRest(function(array, values) {
    return isArrayLikeObject(array)
      ? baseDifference(array, values)
      : [];
  });

  /**
   * Creates an array of unique values that is the
   * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
   * of the given arrays. The order of result values is determined by the order
   * they occur in the arrays.
   *
   * @static
   * @memberOf _
   * @since 2.4.0
   * @category Array
   * @param {...Array} [arrays] The arrays to inspect.
   * @returns {Array} Returns the new array of filtered values.
   * @see _.difference, _.without
   * @example
   *
   * _.xor([2, 1], [2, 3]);
   * // => [1, 3]
   */
  var xor = baseRest(function(arrays) {
    return baseXor(arrayFilter(arrays, isArrayLikeObject));
  });

  /**
   * This method is like `_.xor` except that it accepts `iteratee` which is
   * invoked for each element of each `arrays` to generate the criterion by
   * which by which they're compared. The order of result values is determined
   * by the order they occur in the arrays. The iteratee is invoked with one
   * argument: (value).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {...Array} [arrays] The arrays to inspect.
   * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
   * @returns {Array} Returns the new array of filtered values.
   * @example
   *
   * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
   * // => [1.2, 3.4]
   *
   * // The `_.property` iteratee shorthand.
   * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
   * // => [{ 'x': 2 }]
   */
  var xorBy = baseRest(function(arrays) {
    var iteratee = last(arrays);
    if (isArrayLikeObject(iteratee)) {
      iteratee = undefined;
    }
    return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));
  });

  /**
   * This method is like `_.xor` except that it accepts `comparator` which is
   * invoked to compare elements of `arrays`. The order of result values is
   * determined by the order they occur in the arrays. The comparator is invoked
   * with two arguments: (arrVal, othVal).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Array
   * @param {...Array} [arrays] The arrays to inspect.
   * @param {Function} [comparator] The comparator invoked per element.
   * @returns {Array} Returns the new array of filtered values.
   * @example
   *
   * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
   * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
   *
   * _.xorWith(objects, others, _.isEqual);
   * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
   */
  var xorWith = baseRest(function(arrays) {
    var comparator = last(arrays);
    comparator = typeof comparator == 'function' ? comparator : undefined;
    return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator);
  });

  /**
   * Creates an array of grouped elements, the first of which contains the
   * first elements of the given arrays, the second of which contains the
   * second elements of the given arrays, and so on.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {...Array} [arrays] The arrays to process.
   * @returns {Array} Returns the new array of grouped elements.
   * @example
   *
   * _.zip(['a', 'b'], [1, 2], [true, false]);
   * // => [['a', 1, true], ['b', 2, false]]
   */
  var zip = baseRest(unzip);

  /**
   * This method is like `_.fromPairs` except that it accepts two arrays,
   * one of property identifiers and one of corresponding values.
   *
   * @static
   * @memberOf _
   * @since 0.4.0
   * @category Array
   * @param {Array} [props=[]] The property identifiers.
   * @param {Array} [values=[]] The property values.
   * @returns {Object} Returns the new object.
   * @example
   *
   * _.zipObject(['a', 'b'], [1, 2]);
   * // => { 'a': 1, 'b': 2 }
   */
  function zipObject(props, values) {
    return baseZipObject(props || [], values || [], assignValue);
  }

  /**
   * This method is like `_.zipObject` except that it supports property paths.
   *
   * @static
   * @memberOf _
   * @since 4.1.0
   * @category Array
   * @param {Array} [props=[]] The property identifiers.
   * @param {Array} [values=[]] The property values.
   * @returns {Object} Returns the new object.
   * @example
   *
   * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
   * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
   */
  function zipObjectDeep(props, values) {
    return baseZipObject(props || [], values || [], baseSet);
  }

  /**
   * This method is like `_.zip` except that it accepts `iteratee` to specify
   * how grouped values should be combined. The iteratee is invoked with the
   * elements of each group: (...group).
   *
   * @static
   * @memberOf _
   * @since 3.8.0
   * @category Array
   * @param {...Array} [arrays] The arrays to process.
   * @param {Function} [iteratee=_.identity] The function to combine
   *  grouped values.
   * @returns {Array} Returns the new array of grouped elements.
   * @example
   *
   * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
   *   return a + b + c;
   * });
   * // => [111, 222]
   */
  var zipWith = baseRest(function(arrays) {
    var length = arrays.length,
        iteratee = length > 1 ? arrays[length - 1] : undefined;

    iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined;
    return unzipWith(arrays, iteratee);
  });

  /*------------------------------------------------------------------------*/

  /**
   * Creates a `lodash` wrapper instance that wraps `value` with explicit method
   * chain sequences enabled. The result of such sequences must be unwrapped
   * with `_#value`.
   *
   * @static
   * @memberOf _
   * @since 1.3.0
   * @category Seq
   * @param {*} value The value to wrap.
   * @returns {Object} Returns the new `lodash` wrapper instance.
   * @example
   *
   * var users = [
   *   { 'user': 'barney',  'age': 36 },
   *   { 'user': 'fred',    'age': 40 },
   *   { 'user': 'pebbles', 'age': 1 }
   * ];
   *
   * var youngest = _
   *   .chain(users)
   *   .sortBy('age')
   *   .map(function(o) {
   *     return o.user + ' is ' + o.age;
   *   })
   *   .head()
   *   .value();
   * // => 'pebbles is 1'
   */
  function chain(value) {
    var result = lodash(value);
    result.__chain__ = true;
    return result;
  }

  /**
   * This method invokes `interceptor` and returns `value`. The interceptor
   * is invoked with one argument; (value). The purpose of this method is to
   * "tap into" a method chain sequence in order to modify intermediate results.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Seq
   * @param {*} value The value to provide to `interceptor`.
   * @param {Function} interceptor The function to invoke.
   * @returns {*} Returns `value`.
   * @example
   *
   * _([1, 2, 3])
   *  .tap(function(array) {
   *    // Mutate input array.
   *    array.pop();
   *  })
   *  .reverse()
   *  .value();
   * // => [2, 1]
   */
  function tap(value, interceptor) {
    interceptor(value);
    return value;
  }

  /**
   * This method is like `_.tap` except that it returns the result of `interceptor`.
   * The purpose of this method is to "pass thru" values replacing intermediate
   * results in a method chain sequence.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Seq
   * @param {*} value The value to provide to `interceptor`.
   * @param {Function} interceptor The function to invoke.
   * @returns {*} Returns the result of `interceptor`.
   * @example
   *
   * _('  abc  ')
   *  .chain()
   *  .trim()
   *  .thru(function(value) {
   *    return [value];
   *  })
   *  .value();
   * // => ['abc']
   */
  function thru(value, interceptor) {
    return interceptor(value);
  }

  /**
   * This method is the wrapper version of `_.at`.
   *
   * @name at
   * @memberOf _
   * @since 1.0.0
   * @category Seq
   * @param {...(string|string[])} [paths] The property paths to pick.
   * @returns {Object} Returns the new `lodash` wrapper instance.
   * @example
   *
   * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
   *
   * _(object).at(['a[0].b.c', 'a[1]']).value();
   * // => [3, 4]
   */
  var wrapperAt = flatRest(function(paths) {
    var length = paths.length,
        start = length ? paths[0] : 0,
        value = this.__wrapped__,
        interceptor = function(object) { return baseAt(object, paths); };

    if (length > 1 || this.__actions__.length ||
        !(value instanceof LazyWrapper) || !isIndex(start)) {
      return this.thru(interceptor);
    }
    value = value.slice(start, +start + (length ? 1 : 0));
    value.__actions__.push({
      'func': thru,
      'args': [interceptor],
      'thisArg': undefined
    });
    return new LodashWrapper(value, this.__chain__).thru(function(array) {
      if (length && !array.length) {
        array.push(undefined);
      }
      return array;
    });
  });

  /**
   * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.
   *
   * @name chain
   * @memberOf _
   * @since 0.1.0
   * @category Seq
   * @returns {Object} Returns the new `lodash` wrapper instance.
   * @example
   *
   * var users = [
   *   { 'user': 'barney', 'age': 36 },
   *   { 'user': 'fred',   'age': 40 }
   * ];
   *
   * // A sequence without explicit chaining.
   * _(users).head();
   * // => { 'user': 'barney', 'age': 36 }
   *
   * // A sequence with explicit chaining.
   * _(users)
   *   .chain()
   *   .head()
   *   .pick('user')
   *   .value();
   * // => { 'user': 'barney' }
   */
  function wrapperChain() {
    return chain(this);
  }

  /**
   * Executes the chain sequence and returns the wrapped result.
   *
   * @name commit
   * @memberOf _
   * @since 3.2.0
   * @category Seq
   * @returns {Object} Returns the new `lodash` wrapper instance.
   * @example
   *
   * var array = [1, 2];
   * var wrapped = _(array).push(3);
   *
   * console.log(array);
   * // => [1, 2]
   *
   * wrapped = wrapped.commit();
   * console.log(array);
   * // => [1, 2, 3]
   *
   * wrapped.last();
   * // => 3
   *
   * console.log(array);
   * // => [1, 2, 3]
   */
  function wrapperCommit() {
    return new LodashWrapper(this.value(), this.__chain__);
  }

  /**
   * Gets the next value on a wrapped object following the
   * [iterator protocol](https://mdn.io/iteration_protocols#iterator).
   *
   * @name next
   * @memberOf _
   * @since 4.0.0
   * @category Seq
   * @returns {Object} Returns the next iterator value.
   * @example
   *
   * var wrapped = _([1, 2]);
   *
   * wrapped.next();
   * // => { 'done': false, 'value': 1 }
   *
   * wrapped.next();
   * // => { 'done': false, 'value': 2 }
   *
   * wrapped.next();
   * // => { 'done': true, 'value': undefined }
   */
  function wrapperNext() {
    if (this.__values__ === undefined) {
      this.__values__ = toArray(this.value());
    }
    var done = this.__index__ >= this.__values__.length,
        value = done ? undefined : this.__values__[this.__index__++];

    return { 'done': done, 'value': value };
  }

  /**
   * Enables the wrapper to be iterable.
   *
   * @name Symbol.iterator
   * @memberOf _
   * @since 4.0.0
   * @category Seq
   * @returns {Object} Returns the wrapper object.
   * @example
   *
   * var wrapped = _([1, 2]);
   *
   * wrapped[Symbol.iterator]() === wrapped;
   * // => true
   *
   * Array.from(wrapped);
   * // => [1, 2]
   */
  function wrapperToIterator() {
    return this;
  }

  /**
   * Creates a clone of the chain sequence planting `value` as the wrapped value.
   *
   * @name plant
   * @memberOf _
   * @since 3.2.0
   * @category Seq
   * @param {*} value The value to plant.
   * @returns {Object} Returns the new `lodash` wrapper instance.
   * @example
   *
   * function square(n) {
   *   return n * n;
   * }
   *
   * var wrapped = _([1, 2]).map(square);
   * var other = wrapped.plant([3, 4]);
   *
   * other.value();
   * // => [9, 16]
   *
   * wrapped.value();
   * // => [1, 4]
   */
  function wrapperPlant(value) {
    var result,
        parent = this;

    while (parent instanceof baseLodash) {
      var clone = wrapperClone(parent);
      clone.__index__ = 0;
      clone.__values__ = undefined;
      if (result) {
        previous.__wrapped__ = clone;
      } else {
        result = clone;
      }
      var previous = clone;
      parent = parent.__wrapped__;
    }
    previous.__wrapped__ = value;
    return result;
  }

  /**
   * This method is the wrapper version of `_.reverse`.
   *
   * **Note:** This method mutates the wrapped array.
   *
   * @name reverse
   * @memberOf _
   * @since 0.1.0
   * @category Seq
   * @returns {Object} Returns the new `lodash` wrapper instance.
   * @example
   *
   * var array = [1, 2, 3];
   *
   * _(array).reverse().value()
   * // => [3, 2, 1]
   *
   * console.log(array);
   * // => [3, 2, 1]
   */
  function wrapperReverse() {
    var value = this.__wrapped__;
    if (value instanceof LazyWrapper) {
      var wrapped = value;
      if (this.__actions__.length) {
        wrapped = new LazyWrapper(this);
      }
      wrapped = wrapped.reverse();
      wrapped.__actions__.push({
        'func': thru,
        'args': [reverse],
        'thisArg': undefined
      });
      return new LodashWrapper(wrapped, this.__chain__);
    }
    return this.thru(reverse);
  }

  /**
   * Executes the chain sequence to resolve the unwrapped value.
   *
   * @name value
   * @memberOf _
   * @since 0.1.0
   * @alias toJSON, valueOf
   * @category Seq
   * @returns {*} Returns the resolved unwrapped value.
   * @example
   *
   * _([1, 2, 3]).value();
   * // => [1, 2, 3]
   */
  function wrapperValue() {
    return baseWrapperValue(this.__wrapped__, this.__actions__);
  }

  /*------------------------------------------------------------------------*/

  /**
   * Creates an object composed of keys generated from the results of running
   * each element of `collection` thru `iteratee`. The corresponding value of
   * each key is the number of times the key was returned by `iteratee`. The
   * iteratee is invoked with one argument: (value).
   *
   * @static
   * @memberOf _
   * @since 0.5.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
   * @returns {Object} Returns the composed aggregate object.
   * @example
   *
   * _.countBy([6.1, 4.2, 6.3], Math.floor);
   * // => { '4': 1, '6': 2 }
   *
   * // The `_.property` iteratee shorthand.
   * _.countBy(['one', 'two', 'three'], 'length');
   * // => { '3': 2, '5': 1 }
   */
  var countBy = createAggregator(function(result, value, key) {
    if (hasOwnProperty.call(result, key)) {
      ++result[key];
    } else {
      baseAssignValue(result, key, 1);
    }
  });

  /**
   * Checks if `predicate` returns truthy for **all** elements of `collection`.
   * Iteration is stopped once `predicate` returns falsey. The predicate is
   * invoked with three arguments: (value, index|key, collection).
   *
   * **Note:** This method returns `true` for
   * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because
   * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of
   * elements of empty collections.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {boolean} Returns `true` if all elements pass the predicate check,
   *  else `false`.
   * @example
   *
   * _.every([true, 1, null, 'yes'], Boolean);
   * // => false
   *
   * var users = [
   *   { 'user': 'barney', 'age': 36, 'active': false },
   *   { 'user': 'fred',   'age': 40, 'active': false }
   * ];
   *
   * // The `_.matches` iteratee shorthand.
   * _.every(users, { 'user': 'barney', 'active': false });
   * // => false
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.every(users, ['active', false]);
   * // => true
   *
   * // The `_.property` iteratee shorthand.
   * _.every(users, 'active');
   * // => false
   */
  function every(collection, predicate, guard) {
    var func = isArray(collection) ? arrayEvery : baseEvery;
    if (guard && isIterateeCall(collection, predicate, guard)) {
      predicate = undefined;
    }
    return func(collection, getIteratee(predicate, 3));
  }

  /**
   * Iterates over elements of `collection`, returning an array of all elements
   * `predicate` returns truthy for. The predicate is invoked with three
   * arguments: (value, index|key, collection).
   *
   * **Note:** Unlike `_.remove`, this method returns a new array.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @returns {Array} Returns the new filtered array.
   * @see _.reject
   * @example
   *
   * var users = [
   *   { 'user': 'barney', 'age': 36, 'active': true },
   *   { 'user': 'fred',   'age': 40, 'active': false }
   * ];
   *
   * _.filter(users, function(o) { return !o.active; });
   * // => objects for ['fred']
   *
   * // The `_.matches` iteratee shorthand.
   * _.filter(users, { 'age': 36, 'active': true });
   * // => objects for ['barney']
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.filter(users, ['active', false]);
   * // => objects for ['fred']
   *
   * // The `_.property` iteratee shorthand.
   * _.filter(users, 'active');
   * // => objects for ['barney']
   */
  function filter(collection, predicate) {
    var func = isArray(collection) ? arrayFilter : baseFilter;
    return func(collection, getIteratee(predicate, 3));
  }

  /**
   * Iterates over elements of `collection`, returning the first element
   * `predicate` returns truthy for. The predicate is invoked with three
   * arguments: (value, index|key, collection).
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Collection
   * @param {Array|Object} collection The collection to inspect.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @param {number} [fromIndex=0] The index to search from.
   * @returns {*} Returns the matched element, else `undefined`.
   * @example
   *
   * var users = [
   *   { 'user': 'barney',  'age': 36, 'active': true },
   *   { 'user': 'fred',    'age': 40, 'active': false },
   *   { 'user': 'pebbles', 'age': 1,  'active': true }
   * ];
   *
   * _.find(users, function(o) { return o.age < 40; });
   * // => object for 'barney'
   *
   * // The `_.matches` iteratee shorthand.
   * _.find(users, { 'age': 1, 'active': true });
   * // => object for 'pebbles'
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.find(users, ['active', false]);
   * // => object for 'fred'
   *
   * // The `_.property` iteratee shorthand.
   * _.find(users, 'active');
   * // => object for 'barney'
   */
  var find = createFind(findIndex);

  /**
   * This method is like `_.find` except that it iterates over elements of
   * `collection` from right to left.
   *
   * @static
   * @memberOf _
   * @since 2.0.0
   * @category Collection
   * @param {Array|Object} collection The collection to inspect.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @param {number} [fromIndex=collection.length-1] The index to search from.
   * @returns {*} Returns the matched element, else `undefined`.
   * @example
   *
   * _.findLast([1, 2, 3, 4], function(n) {
   *   return n % 2 == 1;
   * });
   * // => 3
   */
  var findLast = createFind(findLastIndex);

  /**
   * Creates a flattened array of values by running each element in `collection`
   * thru `iteratee` and flattening the mapped results. The iteratee is invoked
   * with three arguments: (value, index|key, collection).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Array} Returns the new flattened array.
   * @example
   *
   * function duplicate(n) {
   *   return [n, n];
   * }
   *
   * _.flatMap([1, 2], duplicate);
   * // => [1, 1, 2, 2]
   */
  function flatMap(collection, iteratee) {
    return baseFlatten(map(collection, iteratee), 1);
  }

  /**
   * This method is like `_.flatMap` except that it recursively flattens the
   * mapped results.
   *
   * @static
   * @memberOf _
   * @since 4.7.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Array} Returns the new flattened array.
   * @example
   *
   * function duplicate(n) {
   *   return [[[n, n]]];
   * }
   *
   * _.flatMapDeep([1, 2], duplicate);
   * // => [1, 1, 2, 2]
   */
  function flatMapDeep(collection, iteratee) {
    return baseFlatten(map(collection, iteratee), INFINITY);
  }

  /**
   * This method is like `_.flatMap` except that it recursively flattens the
   * mapped results up to `depth` times.
   *
   * @static
   * @memberOf _
   * @since 4.7.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @param {number} [depth=1] The maximum recursion depth.
   * @returns {Array} Returns the new flattened array.
   * @example
   *
   * function duplicate(n) {
   *   return [[[n, n]]];
   * }
   *
   * _.flatMapDepth([1, 2], duplicate, 2);
   * // => [[1, 1], [2, 2]]
   */
  function flatMapDepth(collection, iteratee, depth) {
    depth = depth === undefined ? 1 : toInteger(depth);
    return baseFlatten(map(collection, iteratee), depth);
  }

  /**
   * Iterates over elements of `collection` and invokes `iteratee` for each element.
   * The iteratee is invoked with three arguments: (value, index|key, collection).
   * Iteratee functions may exit iteration early by explicitly returning `false`.
   *
   * **Note:** As with other "Collections" methods, objects with a "length"
   * property are iterated like arrays. To avoid this behavior use `_.forIn`
   * or `_.forOwn` for object iteration.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @alias each
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Array|Object} Returns `collection`.
   * @see _.forEachRight
   * @example
   *
   * _.forEach([1, 2], function(value) {
   *   console.log(value);
   * });
   * // => Logs `1` then `2`.
   *
   * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
   *   console.log(key);
   * });
   * // => Logs 'a' then 'b' (iteration order is not guaranteed).
   */
  function forEach(collection, iteratee) {
    var func = isArray(collection) ? arrayEach : baseEach;
    return func(collection, getIteratee(iteratee, 3));
  }

  /**
   * This method is like `_.forEach` except that it iterates over elements of
   * `collection` from right to left.
   *
   * @static
   * @memberOf _
   * @since 2.0.0
   * @alias eachRight
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Array|Object} Returns `collection`.
   * @see _.forEach
   * @example
   *
   * _.forEachRight([1, 2], function(value) {
   *   console.log(value);
   * });
   * // => Logs `2` then `1`.
   */
  function forEachRight(collection, iteratee) {
    var func = isArray(collection) ? arrayEachRight : baseEachRight;
    return func(collection, getIteratee(iteratee, 3));
  }

  /**
   * Creates an object composed of keys generated from the results of running
   * each element of `collection` thru `iteratee`. The order of grouped values
   * is determined by the order they occur in `collection`. The corresponding
   * value of each key is an array of elements responsible for generating the
   * key. The iteratee is invoked with one argument: (value).
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
   * @returns {Object} Returns the composed aggregate object.
   * @example
   *
   * _.groupBy([6.1, 4.2, 6.3], Math.floor);
   * // => { '4': [4.2], '6': [6.1, 6.3] }
   *
   * // The `_.property` iteratee shorthand.
   * _.groupBy(['one', 'two', 'three'], 'length');
   * // => { '3': ['one', 'two'], '5': ['three'] }
   */
  var groupBy = createAggregator(function(result, value, key) {
    if (hasOwnProperty.call(result, key)) {
      result[key].push(value);
    } else {
      baseAssignValue(result, key, [value]);
    }
  });

  /**
   * Checks if `value` is in `collection`. If `collection` is a string, it's
   * checked for a substring of `value`, otherwise
   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * is used for equality comparisons. If `fromIndex` is negative, it's used as
   * the offset from the end of `collection`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Collection
   * @param {Array|Object|string} collection The collection to inspect.
   * @param {*} value The value to search for.
   * @param {number} [fromIndex=0] The index to search from.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
   * @returns {boolean} Returns `true` if `value` is found, else `false`.
   * @example
   *
   * _.includes([1, 2, 3], 1);
   * // => true
   *
   * _.includes([1, 2, 3], 1, 2);
   * // => false
   *
   * _.includes({ 'a': 1, 'b': 2 }, 1);
   * // => true
   *
   * _.includes('abcd', 'bc');
   * // => true
   */
  function includes(collection, value, fromIndex, guard) {
    collection = isArrayLike(collection) ? collection : values(collection);
    fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;

    var length = collection.length;
    if (fromIndex < 0) {
      fromIndex = nativeMax(length + fromIndex, 0);
    }
    return isString(collection)
      ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)
      : (!!length && baseIndexOf(collection, value, fromIndex) > -1);
  }

  /**
   * Invokes the method at `path` of each element in `collection`, returning
   * an array of the results of each invoked method. Any additional arguments
   * are provided to each invoked method. If `path` is a function, it's invoked
   * for, and `this` bound to, each element in `collection`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Array|Function|string} path The path of the method to invoke or
   *  the function invoked per iteration.
   * @param {...*} [args] The arguments to invoke each method with.
   * @returns {Array} Returns the array of results.
   * @example
   *
   * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
   * // => [[1, 5, 7], [1, 2, 3]]
   *
   * _.invokeMap([123, 456], String.prototype.split, '');
   * // => [['1', '2', '3'], ['4', '5', '6']]
   */
  var invokeMap = baseRest(function(collection, path, args) {
    var index = -1,
        isFunc = typeof path == 'function',
        result = isArrayLike(collection) ? Array(collection.length) : [];

    baseEach(collection, function(value) {
      result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
    });
    return result;
  });

  /**
   * Creates an object composed of keys generated from the results of running
   * each element of `collection` thru `iteratee`. The corresponding value of
   * each key is the last element responsible for generating the key. The
   * iteratee is invoked with one argument: (value).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
   * @returns {Object} Returns the composed aggregate object.
   * @example
   *
   * var array = [
   *   { 'dir': 'left', 'code': 97 },
   *   { 'dir': 'right', 'code': 100 }
   * ];
   *
   * _.keyBy(array, function(o) {
   *   return String.fromCharCode(o.code);
   * });
   * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
   *
   * _.keyBy(array, 'dir');
   * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
   */
  var keyBy = createAggregator(function(result, value, key) {
    baseAssignValue(result, key, value);
  });

  /**
   * Creates an array of values by running each element in `collection` thru
   * `iteratee`. The iteratee is invoked with three arguments:
   * (value, index|key, collection).
   *
   * Many lodash methods are guarded to work as iteratees for methods like
   * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
   *
   * The guarded methods are:
   * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
   * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
   * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
   * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Array} Returns the new mapped array.
   * @example
   *
   * function square(n) {
   *   return n * n;
   * }
   *
   * _.map([4, 8], square);
   * // => [16, 64]
   *
   * _.map({ 'a': 4, 'b': 8 }, square);
   * // => [16, 64] (iteration order is not guaranteed)
   *
   * var users = [
   *   { 'user': 'barney' },
   *   { 'user': 'fred' }
   * ];
   *
   * // The `_.property` iteratee shorthand.
   * _.map(users, 'user');
   * // => ['barney', 'fred']
   */
  function map(collection, iteratee) {
    var func = isArray(collection) ? arrayMap : baseMap;
    return func(collection, getIteratee(iteratee, 3));
  }

  /**
   * This method is like `_.sortBy` except that it allows specifying the sort
   * orders of the iteratees to sort by. If `orders` is unspecified, all values
   * are sorted in ascending order. Otherwise, specify an order of "desc" for
   * descending or "asc" for ascending sort order of corresponding values.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]
   *  The iteratees to sort by.
   * @param {string[]} [orders] The sort orders of `iteratees`.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
   * @returns {Array} Returns the new sorted array.
   * @example
   *
   * var users = [
   *   { 'user': 'fred',   'age': 48 },
   *   { 'user': 'barney', 'age': 34 },
   *   { 'user': 'fred',   'age': 40 },
   *   { 'user': 'barney', 'age': 36 }
   * ];
   *
   * // Sort by `user` in ascending order and by `age` in descending order.
   * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
   * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
   */
  function orderBy(collection, iteratees, orders, guard) {
    if (collection == null) {
      return [];
    }
    if (!isArray(iteratees)) {
      iteratees = iteratees == null ? [] : [iteratees];
    }
    orders = guard ? undefined : orders;
    if (!isArray(orders)) {
      orders = orders == null ? [] : [orders];
    }
    return baseOrderBy(collection, iteratees, orders);
  }

  /**
   * Creates an array of elements split into two groups, the first of which
   * contains elements `predicate` returns truthy for, the second of which
   * contains elements `predicate` returns falsey for. The predicate is
   * invoked with one argument: (value).
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @returns {Array} Returns the array of grouped elements.
   * @example
   *
   * var users = [
   *   { 'user': 'barney',  'age': 36, 'active': false },
   *   { 'user': 'fred',    'age': 40, 'active': true },
   *   { 'user': 'pebbles', 'age': 1,  'active': false }
   * ];
   *
   * _.partition(users, function(o) { return o.active; });
   * // => objects for [['fred'], ['barney', 'pebbles']]
   *
   * // The `_.matches` iteratee shorthand.
   * _.partition(users, { 'age': 1, 'active': false });
   * // => objects for [['pebbles'], ['barney', 'fred']]
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.partition(users, ['active', false]);
   * // => objects for [['barney', 'pebbles'], ['fred']]
   *
   * // The `_.property` iteratee shorthand.
   * _.partition(users, 'active');
   * // => objects for [['fred'], ['barney', 'pebbles']]
   */
  var partition = createAggregator(function(result, value, key) {
    result[key ? 0 : 1].push(value);
  }, function() { return [[], []]; });

  /**
   * Reduces `collection` to a value which is the accumulated result of running
   * each element in `collection` thru `iteratee`, where each successive
   * invocation is supplied the return value of the previous. If `accumulator`
   * is not given, the first element of `collection` is used as the initial
   * value. The iteratee is invoked with four arguments:
   * (accumulator, value, index|key, collection).
   *
   * Many lodash methods are guarded to work as iteratees for methods like
   * `_.reduce`, `_.reduceRight`, and `_.transform`.
   *
   * The guarded methods are:
   * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,
   * and `sortBy`
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @param {*} [accumulator] The initial value.
   * @returns {*} Returns the accumulated value.
   * @see _.reduceRight
   * @example
   *
   * _.reduce([1, 2], function(sum, n) {
   *   return sum + n;
   * }, 0);
   * // => 3
   *
   * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
   *   (result[value] || (result[value] = [])).push(key);
   *   return result;
   * }, {});
   * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)
   */
  function reduce(collection, iteratee, accumulator) {
    var func = isArray(collection) ? arrayReduce : baseReduce,
        initAccum = arguments.length < 3;

    return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);
  }

  /**
   * This method is like `_.reduce` except that it iterates over elements of
   * `collection` from right to left.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @param {*} [accumulator] The initial value.
   * @returns {*} Returns the accumulated value.
   * @see _.reduce
   * @example
   *
   * var array = [[0, 1], [2, 3], [4, 5]];
   *
   * _.reduceRight(array, function(flattened, other) {
   *   return flattened.concat(other);
   * }, []);
   * // => [4, 5, 2, 3, 0, 1]
   */
  function reduceRight(collection, iteratee, accumulator) {
    var func = isArray(collection) ? arrayReduceRight : baseReduce,
        initAccum = arguments.length < 3;

    return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);
  }

  /**
   * The opposite of `_.filter`; this method returns the elements of `collection`
   * that `predicate` does **not** return truthy for.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @returns {Array} Returns the new filtered array.
   * @see _.filter
   * @example
   *
   * var users = [
   *   { 'user': 'barney', 'age': 36, 'active': false },
   *   { 'user': 'fred',   'age': 40, 'active': true }
   * ];
   *
   * _.reject(users, function(o) { return !o.active; });
   * // => objects for ['fred']
   *
   * // The `_.matches` iteratee shorthand.
   * _.reject(users, { 'age': 40, 'active': true });
   * // => objects for ['barney']
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.reject(users, ['active', false]);
   * // => objects for ['fred']
   *
   * // The `_.property` iteratee shorthand.
   * _.reject(users, 'active');
   * // => objects for ['barney']
   */
  function reject(collection, predicate) {
    var func = isArray(collection) ? arrayFilter : baseFilter;
    return func(collection, negate(getIteratee(predicate, 3)));
  }

  /**
   * Gets a random element from `collection`.
   *
   * @static
   * @memberOf _
   * @since 2.0.0
   * @category Collection
   * @param {Array|Object} collection The collection to sample.
   * @returns {*} Returns the random element.
   * @example
   *
   * _.sample([1, 2, 3, 4]);
   * // => 2
   */
  function sample(collection) {
    var func = isArray(collection) ? arraySample : baseSample;
    return func(collection);
  }

  /**
   * Gets `n` random elements at unique keys from `collection` up to the
   * size of `collection`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Collection
   * @param {Array|Object} collection The collection to sample.
   * @param {number} [n=1] The number of elements to sample.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {Array} Returns the random elements.
   * @example
   *
   * _.sampleSize([1, 2, 3], 2);
   * // => [3, 1]
   *
   * _.sampleSize([1, 2, 3], 4);
   * // => [2, 3, 1]
   */
  function sampleSize(collection, n, guard) {
    if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) {
      n = 1;
    } else {
      n = toInteger(n);
    }
    var func = isArray(collection) ? arraySampleSize : baseSampleSize;
    return func(collection, n);
  }

  /**
   * Creates an array of shuffled values, using a version of the
   * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Collection
   * @param {Array|Object} collection The collection to shuffle.
   * @returns {Array} Returns the new shuffled array.
   * @example
   *
   * _.shuffle([1, 2, 3, 4]);
   * // => [4, 1, 3, 2]
   */
  function shuffle(collection) {
    var func = isArray(collection) ? arrayShuffle : baseShuffle;
    return func(collection);
  }

  /**
   * Gets the size of `collection` by returning its length for array-like
   * values or the number of own enumerable string keyed properties for objects.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Collection
   * @param {Array|Object|string} collection The collection to inspect.
   * @returns {number} Returns the collection size.
   * @example
   *
   * _.size([1, 2, 3]);
   * // => 3
   *
   * _.size({ 'a': 1, 'b': 2 });
   * // => 2
   *
   * _.size('pebbles');
   * // => 7
   */
  function size(collection) {
    if (collection == null) {
      return 0;
    }
    if (isArrayLike(collection)) {
      return isString(collection) ? stringSize(collection) : collection.length;
    }
    var tag = getTag(collection);
    if (tag == mapTag || tag == setTag) {
      return collection.size;
    }
    return baseKeys(collection).length;
  }

  /**
   * Checks if `predicate` returns truthy for **any** element of `collection`.
   * Iteration is stopped once `predicate` returns truthy. The predicate is
   * invoked with three arguments: (value, index|key, collection).
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {boolean} Returns `true` if any element passes the predicate check,
   *  else `false`.
   * @example
   *
   * _.some([null, 0, 'yes', false], Boolean);
   * // => true
   *
   * var users = [
   *   { 'user': 'barney', 'active': true },
   *   { 'user': 'fred',   'active': false }
   * ];
   *
   * // The `_.matches` iteratee shorthand.
   * _.some(users, { 'user': 'barney', 'active': false });
   * // => false
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.some(users, ['active', false]);
   * // => true
   *
   * // The `_.property` iteratee shorthand.
   * _.some(users, 'active');
   * // => true
   */
  function some(collection, predicate, guard) {
    var func = isArray(collection) ? arraySome : baseSome;
    if (guard && isIterateeCall(collection, predicate, guard)) {
      predicate = undefined;
    }
    return func(collection, getIteratee(predicate, 3));
  }

  /**
   * Creates an array of elements, sorted in ascending order by the results of
   * running each element in a collection thru each iteratee. This method
   * performs a stable sort, that is, it preserves the original sort order of
   * equal elements. The iteratees are invoked with one argument: (value).
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Collection
   * @param {Array|Object} collection The collection to iterate over.
   * @param {...(Function|Function[])} [iteratees=[_.identity]]
   *  The iteratees to sort by.
   * @returns {Array} Returns the new sorted array.
   * @example
   *
   * var users = [
   *   { 'user': 'fred',   'age': 48 },
   *   { 'user': 'barney', 'age': 36 },
   *   { 'user': 'fred',   'age': 40 },
   *   { 'user': 'barney', 'age': 34 }
   * ];
   *
   * _.sortBy(users, [function(o) { return o.user; }]);
   * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
   *
   * _.sortBy(users, ['user', 'age']);
   * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]
   */
  var sortBy = baseRest(function(collection, iteratees) {
    if (collection == null) {
      return [];
    }
    var length = iteratees.length;
    if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
      iteratees = [];
    } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
      iteratees = [iteratees[0]];
    }
    return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
  });

  /*------------------------------------------------------------------------*/

  /**
   * Gets the timestamp of the number of milliseconds that have elapsed since
   * the Unix epoch (1 January 1970 00:00:00 UTC).
   *
   * @static
   * @memberOf _
   * @since 2.4.0
   * @category Date
   * @returns {number} Returns the timestamp.
   * @example
   *
   * _.defer(function(stamp) {
   *   console.log(_.now() - stamp);
   * }, _.now());
   * // => Logs the number of milliseconds it took for the deferred invocation.
   */
  var now = ctxNow || function() {
    return root.Date.now();
  };

  /*------------------------------------------------------------------------*/

  /**
   * The opposite of `_.before`; this method creates a function that invokes
   * `func` once it's called `n` or more times.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Function
   * @param {number} n The number of calls before `func` is invoked.
   * @param {Function} func The function to restrict.
   * @returns {Function} Returns the new restricted function.
   * @example
   *
   * var saves = ['profile', 'settings'];
   *
   * var done = _.after(saves.length, function() {
   *   console.log('done saving!');
   * });
   *
   * _.forEach(saves, function(type) {
   *   asyncSave({ 'type': type, 'complete': done });
   * });
   * // => Logs 'done saving!' after the two async saves have completed.
   */
  function after(n, func) {
    if (typeof func != 'function') {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    n = toInteger(n);
    return function() {
      if (--n < 1) {
        return func.apply(this, arguments);
      }
    };
  }

  /**
   * Creates a function that invokes `func`, with up to `n` arguments,
   * ignoring any additional arguments.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Function
   * @param {Function} func The function to cap arguments for.
   * @param {number} [n=func.length] The arity cap.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {Function} Returns the new capped function.
   * @example
   *
   * _.map(['6', '8', '10'], _.ary(parseInt, 1));
   * // => [6, 8, 10]
   */
  function ary(func, n, guard) {
    n = guard ? undefined : n;
    n = (func && n == null) ? func.length : n;
    return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);
  }

  /**
   * Creates a function that invokes `func`, with the `this` binding and arguments
   * of the created function, while it's called less than `n` times. Subsequent
   * calls to the created function return the result of the last `func` invocation.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Function
   * @param {number} n The number of calls at which `func` is no longer invoked.
   * @param {Function} func The function to restrict.
   * @returns {Function} Returns the new restricted function.
   * @example
   *
   * jQuery(element).on('click', _.before(5, addContactToList));
   * // => Allows adding up to 4 contacts to the list.
   */
  function before(n, func) {
    var result;
    if (typeof func != 'function') {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    n = toInteger(n);
    return function() {
      if (--n > 0) {
        result = func.apply(this, arguments);
      }
      if (n <= 1) {
        func = undefined;
      }
      return result;
    };
  }

  /**
   * Creates a function that invokes `func` with the `this` binding of `thisArg`
   * and `partials` prepended to the arguments it receives.
   *
   * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,
   * may be used as a placeholder for partially applied arguments.
   *
   * **Note:** Unlike native `Function#bind`, this method doesn't set the "length"
   * property of bound functions.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Function
   * @param {Function} func The function to bind.
   * @param {*} thisArg The `this` binding of `func`.
   * @param {...*} [partials] The arguments to be partially applied.
   * @returns {Function} Returns the new bound function.
   * @example
   *
   * function greet(greeting, punctuation) {
   *   return greeting + ' ' + this.user + punctuation;
   * }
   *
   * var object = { 'user': 'fred' };
   *
   * var bound = _.bind(greet, object, 'hi');
   * bound('!');
   * // => 'hi fred!'
   *
   * // Bound with placeholders.
   * var bound = _.bind(greet, object, _, '!');
   * bound('hi');
   * // => 'hi fred!'
   */
  var bind = baseRest(function(func, thisArg, partials) {
    var bitmask = WRAP_BIND_FLAG;
    if (partials.length) {
      var holders = replaceHolders(partials, getHolder(bind));
      bitmask |= WRAP_PARTIAL_FLAG;
    }
    return createWrap(func, bitmask, thisArg, partials, holders);
  });

  /**
   * Creates a function that invokes the method at `object[key]` with `partials`
   * prepended to the arguments it receives.
   *
   * This method differs from `_.bind` by allowing bound functions to reference
   * methods that may be redefined or don't yet exist. See
   * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)
   * for more details.
   *
   * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic
   * builds, may be used as a placeholder for partially applied arguments.
   *
   * @static
   * @memberOf _
   * @since 0.10.0
   * @category Function
   * @param {Object} object The object to invoke the method on.
   * @param {string} key The key of the method.
   * @param {...*} [partials] The arguments to be partially applied.
   * @returns {Function} Returns the new bound function.
   * @example
   *
   * var object = {
   *   'user': 'fred',
   *   'greet': function(greeting, punctuation) {
   *     return greeting + ' ' + this.user + punctuation;
   *   }
   * };
   *
   * var bound = _.bindKey(object, 'greet', 'hi');
   * bound('!');
   * // => 'hi fred!'
   *
   * object.greet = function(greeting, punctuation) {
   *   return greeting + 'ya ' + this.user + punctuation;
   * };
   *
   * bound('!');
   * // => 'hiya fred!'
   *
   * // Bound with placeholders.
   * var bound = _.bindKey(object, 'greet', _, '!');
   * bound('hi');
   * // => 'hiya fred!'
   */
  var bindKey = baseRest(function(object, key, partials) {
    var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
    if (partials.length) {
      var holders = replaceHolders(partials, getHolder(bindKey));
      bitmask |= WRAP_PARTIAL_FLAG;
    }
    return createWrap(key, bitmask, object, partials, holders);
  });

  /**
   * Creates a function that accepts arguments of `func` and either invokes
   * `func` returning its result, if at least `arity` number of arguments have
   * been provided, or returns a function that accepts the remaining `func`
   * arguments, and so on. The arity of `func` may be specified if `func.length`
   * is not sufficient.
   *
   * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,
   * may be used as a placeholder for provided arguments.
   *
   * **Note:** This method doesn't set the "length" property of curried functions.
   *
   * @static
   * @memberOf _
   * @since 2.0.0
   * @category Function
   * @param {Function} func The function to curry.
   * @param {number} [arity=func.length] The arity of `func`.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {Function} Returns the new curried function.
   * @example
   *
   * var abc = function(a, b, c) {
   *   return [a, b, c];
   * };
   *
   * var curried = _.curry(abc);
   *
   * curried(1)(2)(3);
   * // => [1, 2, 3]
   *
   * curried(1, 2)(3);
   * // => [1, 2, 3]
   *
   * curried(1, 2, 3);
   * // => [1, 2, 3]
   *
   * // Curried with placeholders.
   * curried(1)(_, 3)(2);
   * // => [1, 2, 3]
   */
  function curry(func, arity, guard) {
    arity = guard ? undefined : arity;
    var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
    result.placeholder = curry.placeholder;
    return result;
  }

  /**
   * This method is like `_.curry` except that arguments are applied to `func`
   * in the manner of `_.partialRight` instead of `_.partial`.
   *
   * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic
   * builds, may be used as a placeholder for provided arguments.
   *
   * **Note:** This method doesn't set the "length" property of curried functions.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Function
   * @param {Function} func The function to curry.
   * @param {number} [arity=func.length] The arity of `func`.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {Function} Returns the new curried function.
   * @example
   *
   * var abc = function(a, b, c) {
   *   return [a, b, c];
   * };
   *
   * var curried = _.curryRight(abc);
   *
   * curried(3)(2)(1);
   * // => [1, 2, 3]
   *
   * curried(2, 3)(1);
   * // => [1, 2, 3]
   *
   * curried(1, 2, 3);
   * // => [1, 2, 3]
   *
   * // Curried with placeholders.
   * curried(3)(1, _)(2);
   * // => [1, 2, 3]
   */
  function curryRight(func, arity, guard) {
    arity = guard ? undefined : arity;
    var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
    result.placeholder = curryRight.placeholder;
    return result;
  }

  /**
   * Creates a debounced function that delays invoking `func` until after `wait`
   * milliseconds have elapsed since the last time the debounced function was
   * invoked. The debounced function comes with a `cancel` method to cancel
   * delayed `func` invocations and a `flush` method to immediately invoke them.
   * Provide `options` to indicate whether `func` should be invoked on the
   * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
   * with the last arguments provided to the debounced function. Subsequent
   * calls to the debounced function return the result of the last `func`
   * invocation.
   *
   * **Note:** If `leading` and `trailing` options are `true`, `func` is
   * invoked on the trailing edge of the timeout only if the debounced function
   * is invoked more than once during the `wait` timeout.
   *
   * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
   * until to the next tick, similar to `setTimeout` with a timeout of `0`.
   *
   * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
   * for details over the differences between `_.debounce` and `_.throttle`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Function
   * @param {Function} func The function to debounce.
   * @param {number} [wait=0] The number of milliseconds to delay.
   * @param {Object} [options={}] The options object.
   * @param {boolean} [options.leading=false]
   *  Specify invoking on the leading edge of the timeout.
   * @param {number} [options.maxWait]
   *  The maximum time `func` is allowed to be delayed before it's invoked.
   * @param {boolean} [options.trailing=true]
   *  Specify invoking on the trailing edge of the timeout.
   * @returns {Function} Returns the new debounced function.
   * @example
   *
   * // Avoid costly calculations while the window size is in flux.
   * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
   *
   * // Invoke `sendMail` when clicked, debouncing subsequent calls.
   * jQuery(element).on('click', _.debounce(sendMail, 300, {
   *   'leading': true,
   *   'trailing': false
   * }));
   *
   * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
   * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
   * var source = new EventSource('/stream');
   * jQuery(source).on('message', debounced);
   *
   * // Cancel the trailing debounced invocation.
   * jQuery(window).on('popstate', debounced.cancel);
   */
  function debounce(func, wait, options) {
    var lastArgs,
        lastThis,
        maxWait,
        result,
        timerId,
        lastCallTime,
        lastInvokeTime = 0,
        leading = false,
        maxing = false,
        trailing = true;

    if (typeof func != 'function') {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    wait = toNumber(wait) || 0;
    if (isObject(options)) {
      leading = !!options.leading;
      maxing = 'maxWait' in options;
      maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
      trailing = 'trailing' in options ? !!options.trailing : trailing;
    }

    function invokeFunc(time) {
      var args = lastArgs,
          thisArg = lastThis;

      lastArgs = lastThis = undefined;
      lastInvokeTime = time;
      result = func.apply(thisArg, args);
      return result;
    }

    function leadingEdge(time) {
      // Reset any `maxWait` timer.
      lastInvokeTime = time;
      // Start the timer for the trailing edge.
      timerId = setTimeout(timerExpired, wait);
      // Invoke the leading edge.
      return leading ? invokeFunc(time) : result;
    }

    function remainingWait(time) {
      var timeSinceLastCall = time - lastCallTime,
          timeSinceLastInvoke = time - lastInvokeTime,
          result = wait - timeSinceLastCall;

      return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
    }

    function shouldInvoke(time) {
      var timeSinceLastCall = time - lastCallTime,
          timeSinceLastInvoke = time - lastInvokeTime;

      // Either this is the first call, activity has stopped and we're at the
      // trailing edge, the system time has gone backwards and we're treating
      // it as the trailing edge, or we've hit the `maxWait` limit.
      return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
        (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
    }

    function timerExpired() {
      var time = now();
      if (shouldInvoke(time)) {
        return trailingEdge(time);
      }
      // Restart the timer.
      timerId = setTimeout(timerExpired, remainingWait(time));
    }

    function trailingEdge(time) {
      timerId = undefined;

      // Only invoke if we have `lastArgs` which means `func` has been
      // debounced at least once.
      if (trailing && lastArgs) {
        return invokeFunc(time);
      }
      lastArgs = lastThis = undefined;
      return result;
    }

    function cancel() {
      if (timerId !== undefined) {
        clearTimeout(timerId);
      }
      lastInvokeTime = 0;
      lastArgs = lastCallTime = lastThis = timerId = undefined;
    }

    function flush() {
      return timerId === undefined ? result : trailingEdge(now());
    }

    function debounced() {
      var time = now(),
          isInvoking = shouldInvoke(time);

      lastArgs = arguments;
      lastThis = this;
      lastCallTime = time;

      if (isInvoking) {
        if (timerId === undefined) {
          return leadingEdge(lastCallTime);
        }
        if (maxing) {
          // Handle invocations in a tight loop.
          timerId = setTimeout(timerExpired, wait);
          return invokeFunc(lastCallTime);
        }
      }
      if (timerId === undefined) {
        timerId = setTimeout(timerExpired, wait);
      }
      return result;
    }
    debounced.cancel = cancel;
    debounced.flush = flush;
    return debounced;
  }

  /**
   * Defers invoking the `func` until the current call stack has cleared. Any
   * additional arguments are provided to `func` when it's invoked.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Function
   * @param {Function} func The function to defer.
   * @param {...*} [args] The arguments to invoke `func` with.
   * @returns {number} Returns the timer id.
   * @example
   *
   * _.defer(function(text) {
   *   console.log(text);
   * }, 'deferred');
   * // => Logs 'deferred' after one millisecond.
   */
  var defer = baseRest(function(func, args) {
    return baseDelay(func, 1, args);
  });

  /**
   * Invokes `func` after `wait` milliseconds. Any additional arguments are
   * provided to `func` when it's invoked.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Function
   * @param {Function} func The function to delay.
   * @param {number} wait The number of milliseconds to delay invocation.
   * @param {...*} [args] The arguments to invoke `func` with.
   * @returns {number} Returns the timer id.
   * @example
   *
   * _.delay(function(text) {
   *   console.log(text);
   * }, 1000, 'later');
   * // => Logs 'later' after one second.
   */
  var delay = baseRest(function(func, wait, args) {
    return baseDelay(func, toNumber(wait) || 0, args);
  });

  /**
   * Creates a function that invokes `func` with arguments reversed.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Function
   * @param {Function} func The function to flip arguments for.
   * @returns {Function} Returns the new flipped function.
   * @example
   *
   * var flipped = _.flip(function() {
   *   return _.toArray(arguments);
   * });
   *
   * flipped('a', 'b', 'c', 'd');
   * // => ['d', 'c', 'b', 'a']
   */
  function flip(func) {
    return createWrap(func, WRAP_FLIP_FLAG);
  }

  /**
   * Creates a function that memoizes the result of `func`. If `resolver` is
   * provided, it determines the cache key for storing the result based on the
   * arguments provided to the memoized function. By default, the first argument
   * provided to the memoized function is used as the map cache key. The `func`
   * is invoked with the `this` binding of the memoized function.
   *
   * **Note:** The cache is exposed as the `cache` property on the memoized
   * function. Its creation may be customized by replacing the `_.memoize.Cache`
   * constructor with one whose instances implement the
   * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
   * method interface of `clear`, `delete`, `get`, `has`, and `set`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Function
   * @param {Function} func The function to have its output memoized.
   * @param {Function} [resolver] The function to resolve the cache key.
   * @returns {Function} Returns the new memoized function.
   * @example
   *
   * var object = { 'a': 1, 'b': 2 };
   * var other = { 'c': 3, 'd': 4 };
   *
   * var values = _.memoize(_.values);
   * values(object);
   * // => [1, 2]
   *
   * values(other);
   * // => [3, 4]
   *
   * object.a = 2;
   * values(object);
   * // => [1, 2]
   *
   * // Modify the result cache.
   * values.cache.set(object, ['a', 'b']);
   * values(object);
   * // => ['a', 'b']
   *
   * // Replace `_.memoize.Cache`.
   * _.memoize.Cache = WeakMap;
   */
  function memoize(func, resolver) {
    if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    var memoized = function() {
      var args = arguments,
          key = resolver ? resolver.apply(this, args) : args[0],
          cache = memoized.cache;

      if (cache.has(key)) {
        return cache.get(key);
      }
      var result = func.apply(this, args);
      memoized.cache = cache.set(key, result) || cache;
      return result;
    };
    memoized.cache = new (memoize.Cache || MapCache);
    return memoized;
  }

  // Expose `MapCache`.
  memoize.Cache = MapCache;

  /**
   * Creates a function that negates the result of the predicate `func`. The
   * `func` predicate is invoked with the `this` binding and arguments of the
   * created function.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Function
   * @param {Function} predicate The predicate to negate.
   * @returns {Function} Returns the new negated function.
   * @example
   *
   * function isEven(n) {
   *   return n % 2 == 0;
   * }
   *
   * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
   * // => [1, 3, 5]
   */
  function negate(predicate) {
    if (typeof predicate != 'function') {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    return function() {
      var args = arguments;
      switch (args.length) {
        case 0: return !predicate.call(this);
        case 1: return !predicate.call(this, args[0]);
        case 2: return !predicate.call(this, args[0], args[1]);
        case 3: return !predicate.call(this, args[0], args[1], args[2]);
      }
      return !predicate.apply(this, args);
    };
  }

  /**
   * Creates a function that is restricted to invoking `func` once. Repeat calls
   * to the function return the value of the first invocation. The `func` is
   * invoked with the `this` binding and arguments of the created function.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Function
   * @param {Function} func The function to restrict.
   * @returns {Function} Returns the new restricted function.
   * @example
   *
   * var initialize = _.once(createApplication);
   * initialize();
   * initialize();
   * // => `createApplication` is invoked once
   */
  function once(func) {
    return before(2, func);
  }

  /**
   * Creates a function that invokes `func` with its arguments transformed.
   *
   * @static
   * @since 4.0.0
   * @memberOf _
   * @category Function
   * @param {Function} func The function to wrap.
   * @param {...(Function|Function[])} [transforms=[_.identity]]
   *  The argument transforms.
   * @returns {Function} Returns the new function.
   * @example
   *
   * function doubled(n) {
   *   return n * 2;
   * }
   *
   * function square(n) {
   *   return n * n;
   * }
   *
   * var func = _.overArgs(function(x, y) {
   *   return [x, y];
   * }, [square, doubled]);
   *
   * func(9, 3);
   * // => [81, 6]
   *
   * func(10, 5);
   * // => [100, 10]
   */
  var overArgs = castRest(function(func, transforms) {
    transforms = (transforms.length == 1 && isArray(transforms[0]))
      ? arrayMap(transforms[0], baseUnary(getIteratee()))
      : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));

    var funcsLength = transforms.length;
    return baseRest(function(args) {
      var index = -1,
          length = nativeMin(args.length, funcsLength);

      while (++index < length) {
        args[index] = transforms[index].call(this, args[index]);
      }
      return apply(func, this, args);
    });
  });

  /**
   * Creates a function that invokes `func` with `partials` prepended to the
   * arguments it receives. This method is like `_.bind` except it does **not**
   * alter the `this` binding.
   *
   * The `_.partial.placeholder` value, which defaults to `_` in monolithic
   * builds, may be used as a placeholder for partially applied arguments.
   *
   * **Note:** This method doesn't set the "length" property of partially
   * applied functions.
   *
   * @static
   * @memberOf _
   * @since 0.2.0
   * @category Function
   * @param {Function} func The function to partially apply arguments to.
   * @param {...*} [partials] The arguments to be partially applied.
   * @returns {Function} Returns the new partially applied function.
   * @example
   *
   * function greet(greeting, name) {
   *   return greeting + ' ' + name;
   * }
   *
   * var sayHelloTo = _.partial(greet, 'hello');
   * sayHelloTo('fred');
   * // => 'hello fred'
   *
   * // Partially applied with placeholders.
   * var greetFred = _.partial(greet, _, 'fred');
   * greetFred('hi');
   * // => 'hi fred'
   */
  var partial = baseRest(function(func, partials) {
    var holders = replaceHolders(partials, getHolder(partial));
    return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);
  });

  /**
   * This method is like `_.partial` except that partially applied arguments
   * are appended to the arguments it receives.
   *
   * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic
   * builds, may be used as a placeholder for partially applied arguments.
   *
   * **Note:** This method doesn't set the "length" property of partially
   * applied functions.
   *
   * @static
   * @memberOf _
   * @since 1.0.0
   * @category Function
   * @param {Function} func The function to partially apply arguments to.
   * @param {...*} [partials] The arguments to be partially applied.
   * @returns {Function} Returns the new partially applied function.
   * @example
   *
   * function greet(greeting, name) {
   *   return greeting + ' ' + name;
   * }
   *
   * var greetFred = _.partialRight(greet, 'fred');
   * greetFred('hi');
   * // => 'hi fred'
   *
   * // Partially applied with placeholders.
   * var sayHelloTo = _.partialRight(greet, 'hello', _);
   * sayHelloTo('fred');
   * // => 'hello fred'
   */
  var partialRight = baseRest(function(func, partials) {
    var holders = replaceHolders(partials, getHolder(partialRight));
    return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders);
  });

  /**
   * Creates a function that invokes `func` with arguments arranged according
   * to the specified `indexes` where the argument value at the first index is
   * provided as the first argument, the argument value at the second index is
   * provided as the second argument, and so on.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Function
   * @param {Function} func The function to rearrange arguments for.
   * @param {...(number|number[])} indexes The arranged argument indexes.
   * @returns {Function} Returns the new function.
   * @example
   *
   * var rearged = _.rearg(function(a, b, c) {
   *   return [a, b, c];
   * }, [2, 0, 1]);
   *
   * rearged('b', 'c', 'a')
   * // => ['a', 'b', 'c']
   */
  var rearg = flatRest(function(func, indexes) {
    return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);
  });

  /**
   * Creates a function that invokes `func` with the `this` binding of the
   * created function and arguments from `start` and beyond provided as
   * an array.
   *
   * **Note:** This method is based on the
   * [rest parameter](https://mdn.io/rest_parameters).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Function
   * @param {Function} func The function to apply a rest parameter to.
   * @param {number} [start=func.length-1] The start position of the rest parameter.
   * @returns {Function} Returns the new function.
   * @example
   *
   * var say = _.rest(function(what, names) {
   *   return what + ' ' + _.initial(names).join(', ') +
   *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);
   * });
   *
   * say('hello', 'fred', 'barney', 'pebbles');
   * // => 'hello fred, barney, & pebbles'
   */
  function rest(func, start) {
    if (typeof func != 'function') {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    start = start === undefined ? start : toInteger(start);
    return baseRest(func, start);
  }

  /**
   * Creates a function that invokes `func` with the `this` binding of the
   * create function and an array of arguments much like
   * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).
   *
   * **Note:** This method is based on the
   * [spread operator](https://mdn.io/spread_operator).
   *
   * @static
   * @memberOf _
   * @since 3.2.0
   * @category Function
   * @param {Function} func The function to spread arguments over.
   * @param {number} [start=0] The start position of the spread.
   * @returns {Function} Returns the new function.
   * @example
   *
   * var say = _.spread(function(who, what) {
   *   return who + ' says ' + what;
   * });
   *
   * say(['fred', 'hello']);
   * // => 'fred says hello'
   *
   * var numbers = Promise.all([
   *   Promise.resolve(40),
   *   Promise.resolve(36)
   * ]);
   *
   * numbers.then(_.spread(function(x, y) {
   *   return x + y;
   * }));
   * // => a Promise of 76
   */
  function spread(func, start) {
    if (typeof func != 'function') {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    start = start == null ? 0 : nativeMax(toInteger(start), 0);
    return baseRest(function(args) {
      var array = args[start],
          otherArgs = castSlice(args, 0, start);

      if (array) {
        arrayPush(otherArgs, array);
      }
      return apply(func, this, otherArgs);
    });
  }

  /**
   * Creates a throttled function that only invokes `func` at most once per
   * every `wait` milliseconds. The throttled function comes with a `cancel`
   * method to cancel delayed `func` invocations and a `flush` method to
   * immediately invoke them. Provide `options` to indicate whether `func`
   * should be invoked on the leading and/or trailing edge of the `wait`
   * timeout. The `func` is invoked with the last arguments provided to the
   * throttled function. Subsequent calls to the throttled function return the
   * result of the last `func` invocation.
   *
   * **Note:** If `leading` and `trailing` options are `true`, `func` is
   * invoked on the trailing edge of the timeout only if the throttled function
   * is invoked more than once during the `wait` timeout.
   *
   * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
   * until to the next tick, similar to `setTimeout` with a timeout of `0`.
   *
   * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
   * for details over the differences between `_.throttle` and `_.debounce`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Function
   * @param {Function} func The function to throttle.
   * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
   * @param {Object} [options={}] The options object.
   * @param {boolean} [options.leading=true]
   *  Specify invoking on the leading edge of the timeout.
   * @param {boolean} [options.trailing=true]
   *  Specify invoking on the trailing edge of the timeout.
   * @returns {Function} Returns the new throttled function.
   * @example
   *
   * // Avoid excessively updating the position while scrolling.
   * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
   *
   * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
   * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
   * jQuery(element).on('click', throttled);
   *
   * // Cancel the trailing throttled invocation.
   * jQuery(window).on('popstate', throttled.cancel);
   */
  function throttle(func, wait, options) {
    var leading = true,
        trailing = true;

    if (typeof func != 'function') {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    if (isObject(options)) {
      leading = 'leading' in options ? !!options.leading : leading;
      trailing = 'trailing' in options ? !!options.trailing : trailing;
    }
    return debounce(func, wait, {
      'leading': leading,
      'maxWait': wait,
      'trailing': trailing
    });
  }

  /**
   * Creates a function that accepts up to one argument, ignoring any
   * additional arguments.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Function
   * @param {Function} func The function to cap arguments for.
   * @returns {Function} Returns the new capped function.
   * @example
   *
   * _.map(['6', '8', '10'], _.unary(parseInt));
   * // => [6, 8, 10]
   */
  function unary(func) {
    return ary(func, 1);
  }

  /**
   * Creates a function that provides `value` to `wrapper` as its first
   * argument. Any additional arguments provided to the function are appended
   * to those provided to the `wrapper`. The wrapper is invoked with the `this`
   * binding of the created function.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Function
   * @param {*} value The value to wrap.
   * @param {Function} [wrapper=identity] The wrapper function.
   * @returns {Function} Returns the new function.
   * @example
   *
   * var p = _.wrap(_.escape, function(func, text) {
   *   return '<p>' + func(text) + '</p>';
   * });
   *
   * p('fred, barney, & pebbles');
   * // => '<p>fred, barney, &amp; pebbles</p>'
   */
  function wrap(value, wrapper) {
    return partial(castFunction(wrapper), value);
  }

  /*------------------------------------------------------------------------*/

  /**
   * Casts `value` as an array if it's not one.
   *
   * @static
   * @memberOf _
   * @since 4.4.0
   * @category Lang
   * @param {*} value The value to inspect.
   * @returns {Array} Returns the cast array.
   * @example
   *
   * _.castArray(1);
   * // => [1]
   *
   * _.castArray({ 'a': 1 });
   * // => [{ 'a': 1 }]
   *
   * _.castArray('abc');
   * // => ['abc']
   *
   * _.castArray(null);
   * // => [null]
   *
   * _.castArray(undefined);
   * // => [undefined]
   *
   * _.castArray();
   * // => []
   *
   * var array = [1, 2, 3];
   * console.log(_.castArray(array) === array);
   * // => true
   */
  function castArray() {
    if (!arguments.length) {
      return [];
    }
    var value = arguments[0];
    return isArray(value) ? value : [value];
  }

  /**
   * Creates a shallow clone of `value`.
   *
   * **Note:** This method is loosely based on the
   * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
   * and supports cloning arrays, array buffers, booleans, date objects, maps,
   * numbers, `Object` objects, regexes, sets, strings, symbols, and typed
   * arrays. The own enumerable properties of `arguments` objects are cloned
   * as plain objects. An empty object is returned for uncloneable values such
   * as error objects, functions, DOM nodes, and WeakMaps.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to clone.
   * @returns {*} Returns the cloned value.
   * @see _.cloneDeep
   * @example
   *
   * var objects = [{ 'a': 1 }, { 'b': 2 }];
   *
   * var shallow = _.clone(objects);
   * console.log(shallow[0] === objects[0]);
   * // => true
   */
  function clone(value) {
    return baseClone(value, CLONE_SYMBOLS_FLAG);
  }

  /**
   * This method is like `_.clone` except that it accepts `customizer` which
   * is invoked to produce the cloned value. If `customizer` returns `undefined`,
   * cloning is handled by the method instead. The `customizer` is invoked with
   * up to four arguments; (value [, index|key, object, stack]).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to clone.
   * @param {Function} [customizer] The function to customize cloning.
   * @returns {*} Returns the cloned value.
   * @see _.cloneDeepWith
   * @example
   *
   * function customizer(value) {
   *   if (_.isElement(value)) {
   *     return value.cloneNode(false);
   *   }
   * }
   *
   * var el = _.cloneWith(document.body, customizer);
   *
   * console.log(el === document.body);
   * // => false
   * console.log(el.nodeName);
   * // => 'BODY'
   * console.log(el.childNodes.length);
   * // => 0
   */
  function cloneWith(value, customizer) {
    customizer = typeof customizer == 'function' ? customizer : undefined;
    return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
  }

  /**
   * This method is like `_.clone` except that it recursively clones `value`.
   *
   * @static
   * @memberOf _
   * @since 1.0.0
   * @category Lang
   * @param {*} value The value to recursively clone.
   * @returns {*} Returns the deep cloned value.
   * @see _.clone
   * @example
   *
   * var objects = [{ 'a': 1 }, { 'b': 2 }];
   *
   * var deep = _.cloneDeep(objects);
   * console.log(deep[0] === objects[0]);
   * // => false
   */
  function cloneDeep(value) {
    return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
  }

  /**
   * This method is like `_.cloneWith` except that it recursively clones `value`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to recursively clone.
   * @param {Function} [customizer] The function to customize cloning.
   * @returns {*} Returns the deep cloned value.
   * @see _.cloneWith
   * @example
   *
   * function customizer(value) {
   *   if (_.isElement(value)) {
   *     return value.cloneNode(true);
   *   }
   * }
   *
   * var el = _.cloneDeepWith(document.body, customizer);
   *
   * console.log(el === document.body);
   * // => false
   * console.log(el.nodeName);
   * // => 'BODY'
   * console.log(el.childNodes.length);
   * // => 20
   */
  function cloneDeepWith(value, customizer) {
    customizer = typeof customizer == 'function' ? customizer : undefined;
    return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
  }

  /**
   * Checks if `object` conforms to `source` by invoking the predicate
   * properties of `source` with the corresponding property values of `object`.
   *
   * **Note:** This method is equivalent to `_.conforms` when `source` is
   * partially applied.
   *
   * @static
   * @memberOf _
   * @since 4.14.0
   * @category Lang
   * @param {Object} object The object to inspect.
   * @param {Object} source The object of property predicates to conform to.
   * @returns {boolean} Returns `true` if `object` conforms, else `false`.
   * @example
   *
   * var object = { 'a': 1, 'b': 2 };
   *
   * _.conformsTo(object, { 'b': function(n) { return n > 1; } });
   * // => true
   *
   * _.conformsTo(object, { 'b': function(n) { return n > 2; } });
   * // => false
   */
  function conformsTo(object, source) {
    return source == null || baseConformsTo(object, source, keys(source));
  }

  /**
   * Performs a
   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * comparison between two values to determine if they are equivalent.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
   * @example
   *
   * var object = { 'a': 1 };
   * var other = { 'a': 1 };
   *
   * _.eq(object, object);
   * // => true
   *
   * _.eq(object, other);
   * // => false
   *
   * _.eq('a', 'a');
   * // => true
   *
   * _.eq('a', Object('a'));
   * // => false
   *
   * _.eq(NaN, NaN);
   * // => true
   */
  function eq(value, other) {
    return value === other || (value !== value && other !== other);
  }

  /**
   * Checks if `value` is greater than `other`.
   *
   * @static
   * @memberOf _
   * @since 3.9.0
   * @category Lang
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {boolean} Returns `true` if `value` is greater than `other`,
   *  else `false`.
   * @see _.lt
   * @example
   *
   * _.gt(3, 1);
   * // => true
   *
   * _.gt(3, 3);
   * // => false
   *
   * _.gt(1, 3);
   * // => false
   */
  var gt = createRelationalOperation(baseGt);

  /**
   * Checks if `value` is greater than or equal to `other`.
   *
   * @static
   * @memberOf _
   * @since 3.9.0
   * @category Lang
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {boolean} Returns `true` if `value` is greater than or equal to
   *  `other`, else `false`.
   * @see _.lte
   * @example
   *
   * _.gte(3, 1);
   * // => true
   *
   * _.gte(3, 3);
   * // => true
   *
   * _.gte(1, 3);
   * // => false
   */
  var gte = createRelationalOperation(function(value, other) {
    return value >= other;
  });

  /**
   * Checks if `value` is likely an `arguments` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an `arguments` object,
   *  else `false`.
   * @example
   *
   * _.isArguments(function() { return arguments; }());
   * // => true
   *
   * _.isArguments([1, 2, 3]);
   * // => false
   */
  var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
    return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
      !propertyIsEnumerable.call(value, 'callee');
  };

  /**
   * Checks if `value` is classified as an `Array` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an array, else `false`.
   * @example
   *
   * _.isArray([1, 2, 3]);
   * // => true
   *
   * _.isArray(document.body.children);
   * // => false
   *
   * _.isArray('abc');
   * // => false
   *
   * _.isArray(_.noop);
   * // => false
   */
  var isArray = Array.isArray;

  /**
   * Checks if `value` is classified as an `ArrayBuffer` object.
   *
   * @static
   * @memberOf _
   * @since 4.3.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
   * @example
   *
   * _.isArrayBuffer(new ArrayBuffer(2));
   * // => true
   *
   * _.isArrayBuffer(new Array(2));
   * // => false
   */
  var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;

  /**
   * Checks if `value` is array-like. A value is considered array-like if it's
   * not a function and has a `value.length` that's an integer greater than or
   * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
   * @example
   *
   * _.isArrayLike([1, 2, 3]);
   * // => true
   *
   * _.isArrayLike(document.body.children);
   * // => true
   *
   * _.isArrayLike('abc');
   * // => true
   *
   * _.isArrayLike(_.noop);
   * // => false
   */
  function isArrayLike(value) {
    return value != null && isLength(value.length) && !isFunction(value);
  }

  /**
   * This method is like `_.isArrayLike` except that it also checks if `value`
   * is an object.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an array-like object,
   *  else `false`.
   * @example
   *
   * _.isArrayLikeObject([1, 2, 3]);
   * // => true
   *
   * _.isArrayLikeObject(document.body.children);
   * // => true
   *
   * _.isArrayLikeObject('abc');
   * // => false
   *
   * _.isArrayLikeObject(_.noop);
   * // => false
   */
  function isArrayLikeObject(value) {
    return isObjectLike(value) && isArrayLike(value);
  }

  /**
   * Checks if `value` is classified as a boolean primitive or object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.
   * @example
   *
   * _.isBoolean(false);
   * // => true
   *
   * _.isBoolean(null);
   * // => false
   */
  function isBoolean(value) {
    return value === true || value === false ||
      (isObjectLike(value) && baseGetTag(value) == boolTag);
  }

  /**
   * Checks if `value` is a buffer.
   *
   * @static
   * @memberOf _
   * @since 4.3.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
   * @example
   *
   * _.isBuffer(new Buffer(2));
   * // => true
   *
   * _.isBuffer(new Uint8Array(2));
   * // => false
   */
  var isBuffer = nativeIsBuffer || stubFalse;

  /**
   * Checks if `value` is classified as a `Date` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
   * @example
   *
   * _.isDate(new Date);
   * // => true
   *
   * _.isDate('Mon April 23 2012');
   * // => false
   */
  var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;

  /**
   * Checks if `value` is likely a DOM element.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
   * @example
   *
   * _.isElement(document.body);
   * // => true
   *
   * _.isElement('<body>');
   * // => false
   */
  function isElement(value) {
    return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
  }

  /**
   * Checks if `value` is an empty object, collection, map, or set.
   *
   * Objects are considered empty if they have no own enumerable string keyed
   * properties.
   *
   * Array-like values such as `arguments` objects, arrays, buffers, strings, or
   * jQuery-like collections are considered empty if they have a `length` of `0`.
   * Similarly, maps and sets are considered empty if they have a `size` of `0`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is empty, else `false`.
   * @example
   *
   * _.isEmpty(null);
   * // => true
   *
   * _.isEmpty(true);
   * // => true
   *
   * _.isEmpty(1);
   * // => true
   *
   * _.isEmpty([1, 2, 3]);
   * // => false
   *
   * _.isEmpty({ 'a': 1 });
   * // => false
   */
  function isEmpty(value) {
    if (value == null) {
      return true;
    }
    if (isArrayLike(value) &&
        (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||
          isBuffer(value) || isTypedArray(value) || isArguments(value))) {
      return !value.length;
    }
    var tag = getTag(value);
    if (tag == mapTag || tag == setTag) {
      return !value.size;
    }
    if (isPrototype(value)) {
      return !baseKeys(value).length;
    }
    for (var key in value) {
      if (hasOwnProperty.call(value, key)) {
        return false;
      }
    }
    return true;
  }

  /**
   * Performs a deep comparison between two values to determine if they are
   * equivalent.
   *
   * **Note:** This method supports comparing arrays, array buffers, booleans,
   * date objects, error objects, maps, numbers, `Object` objects, regexes,
   * sets, strings, symbols, and typed arrays. `Object` objects are compared
   * by their own, not inherited, enumerable properties. Functions and DOM
   * nodes are compared by strict equality, i.e. `===`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
   * @example
   *
   * var object = { 'a': 1 };
   * var other = { 'a': 1 };
   *
   * _.isEqual(object, other);
   * // => true
   *
   * object === other;
   * // => false
   */
  function isEqual(value, other) {
    return baseIsEqual(value, other);
  }

  /**
   * This method is like `_.isEqual` except that it accepts `customizer` which
   * is invoked to compare values. If `customizer` returns `undefined`, comparisons
   * are handled by the method instead. The `customizer` is invoked with up to
   * six arguments: (objValue, othValue [, index|key, object, other, stack]).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @param {Function} [customizer] The function to customize comparisons.
   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
   * @example
   *
   * function isGreeting(value) {
   *   return /^h(?:i|ello)$/.test(value);
   * }
   *
   * function customizer(objValue, othValue) {
   *   if (isGreeting(objValue) && isGreeting(othValue)) {
   *     return true;
   *   }
   * }
   *
   * var array = ['hello', 'goodbye'];
   * var other = ['hi', 'goodbye'];
   *
   * _.isEqualWith(array, other, customizer);
   * // => true
   */
  function isEqualWith(value, other, customizer) {
    customizer = typeof customizer == 'function' ? customizer : undefined;
    var result = customizer ? customizer(value, other) : undefined;
    return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;
  }

  /**
   * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,
   * `SyntaxError`, `TypeError`, or `URIError` object.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an error object, else `false`.
   * @example
   *
   * _.isError(new Error);
   * // => true
   *
   * _.isError(Error);
   * // => false
   */
  function isError(value) {
    if (!isObjectLike(value)) {
      return false;
    }
    var tag = baseGetTag(value);
    return tag == errorTag || tag == domExcTag ||
      (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));
  }

  /**
   * Checks if `value` is a finite primitive number.
   *
   * **Note:** This method is based on
   * [`Number.isFinite`](https://mdn.io/Number/isFinite).
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.
   * @example
   *
   * _.isFinite(3);
   * // => true
   *
   * _.isFinite(Number.MIN_VALUE);
   * // => true
   *
   * _.isFinite(Infinity);
   * // => false
   *
   * _.isFinite('3');
   * // => false
   */
  function isFinite(value) {
    return typeof value == 'number' && nativeIsFinite(value);
  }

  /**
   * Checks if `value` is classified as a `Function` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a function, else `false`.
   * @example
   *
   * _.isFunction(_);
   * // => true
   *
   * _.isFunction(/abc/);
   * // => false
   */
  function isFunction(value) {
    if (!isObject(value)) {
      return false;
    }
    // The use of `Object#toString` avoids issues with the `typeof` operator
    // in Safari 9 which returns 'object' for typed arrays and other constructors.
    var tag = baseGetTag(value);
    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
  }

  /**
   * Checks if `value` is an integer.
   *
   * **Note:** This method is based on
   * [`Number.isInteger`](https://mdn.io/Number/isInteger).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an integer, else `false`.
   * @example
   *
   * _.isInteger(3);
   * // => true
   *
   * _.isInteger(Number.MIN_VALUE);
   * // => false
   *
   * _.isInteger(Infinity);
   * // => false
   *
   * _.isInteger('3');
   * // => false
   */
  function isInteger(value) {
    return typeof value == 'number' && value == toInteger(value);
  }

  /**
   * Checks if `value` is a valid array-like length.
   *
   * **Note:** This method is loosely based on
   * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
   * @example
   *
   * _.isLength(3);
   * // => true
   *
   * _.isLength(Number.MIN_VALUE);
   * // => false
   *
   * _.isLength(Infinity);
   * // => false
   *
   * _.isLength('3');
   * // => false
   */
  function isLength(value) {
    return typeof value == 'number' &&
      value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
  }

  /**
   * Checks if `value` is the
   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
   * @example
   *
   * _.isObject({});
   * // => true
   *
   * _.isObject([1, 2, 3]);
   * // => true
   *
   * _.isObject(_.noop);
   * // => true
   *
   * _.isObject(null);
   * // => false
   */
  function isObject(value) {
    var type = typeof value;
    return value != null && (type == 'object' || type == 'function');
  }

  /**
   * Checks if `value` is object-like. A value is object-like if it's not `null`
   * and has a `typeof` result of "object".
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
   * @example
   *
   * _.isObjectLike({});
   * // => true
   *
   * _.isObjectLike([1, 2, 3]);
   * // => true
   *
   * _.isObjectLike(_.noop);
   * // => false
   *
   * _.isObjectLike(null);
   * // => false
   */
  function isObjectLike(value) {
    return value != null && typeof value == 'object';
  }

  /**
   * Checks if `value` is classified as a `Map` object.
   *
   * @static
   * @memberOf _
   * @since 4.3.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a map, else `false`.
   * @example
   *
   * _.isMap(new Map);
   * // => true
   *
   * _.isMap(new WeakMap);
   * // => false
   */
  var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;

  /**
   * Performs a partial deep comparison between `object` and `source` to
   * determine if `object` contains equivalent property values.
   *
   * **Note:** This method is equivalent to `_.matches` when `source` is
   * partially applied.
   *
   * Partial comparisons will match empty array and empty object `source`
   * values against any array or object value, respectively. See `_.isEqual`
   * for a list of supported value comparisons.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Lang
   * @param {Object} object The object to inspect.
   * @param {Object} source The object of property values to match.
   * @returns {boolean} Returns `true` if `object` is a match, else `false`.
   * @example
   *
   * var object = { 'a': 1, 'b': 2 };
   *
   * _.isMatch(object, { 'b': 2 });
   * // => true
   *
   * _.isMatch(object, { 'b': 1 });
   * // => false
   */
  function isMatch(object, source) {
    return object === source || baseIsMatch(object, source, getMatchData(source));
  }

  /**
   * This method is like `_.isMatch` except that it accepts `customizer` which
   * is invoked to compare values. If `customizer` returns `undefined`, comparisons
   * are handled by the method instead. The `customizer` is invoked with five
   * arguments: (objValue, srcValue, index|key, object, source).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {Object} object The object to inspect.
   * @param {Object} source The object of property values to match.
   * @param {Function} [customizer] The function to customize comparisons.
   * @returns {boolean} Returns `true` if `object` is a match, else `false`.
   * @example
   *
   * function isGreeting(value) {
   *   return /^h(?:i|ello)$/.test(value);
   * }
   *
   * function customizer(objValue, srcValue) {
   *   if (isGreeting(objValue) && isGreeting(srcValue)) {
   *     return true;
   *   }
   * }
   *
   * var object = { 'greeting': 'hello' };
   * var source = { 'greeting': 'hi' };
   *
   * _.isMatchWith(object, source, customizer);
   * // => true
   */
  function isMatchWith(object, source, customizer) {
    customizer = typeof customizer == 'function' ? customizer : undefined;
    return baseIsMatch(object, source, getMatchData(source), customizer);
  }

  /**
   * Checks if `value` is `NaN`.
   *
   * **Note:** This method is based on
   * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as
   * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for
   * `undefined` and other non-number values.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
   * @example
   *
   * _.isNaN(NaN);
   * // => true
   *
   * _.isNaN(new Number(NaN));
   * // => true
   *
   * isNaN(undefined);
   * // => true
   *
   * _.isNaN(undefined);
   * // => false
   */
  function isNaN(value) {
    // An `NaN` primitive is the only value that is not equal to itself.
    // Perform the `toStringTag` check first to avoid errors with some
    // ActiveX objects in IE.
    return isNumber(value) && value != +value;
  }

  /**
   * Checks if `value` is a pristine native function.
   *
   * **Note:** This method can't reliably detect native functions in the presence
   * of the core-js package because core-js circumvents this kind of detection.
   * Despite multiple requests, the core-js maintainer has made it clear: any
   * attempt to fix the detection will be obstructed. As a result, we're left
   * with little choice but to throw an error. Unfortunately, this also affects
   * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),
   * which rely on core-js.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a native function,
   *  else `false`.
   * @example
   *
   * _.isNative(Array.prototype.push);
   * // => true
   *
   * _.isNative(_);
   * // => false
   */
  function isNative(value) {
    if (isMaskable(value)) {
      throw new Error(CORE_ERROR_TEXT);
    }
    return baseIsNative(value);
  }

  /**
   * Checks if `value` is `null`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is `null`, else `false`.
   * @example
   *
   * _.isNull(null);
   * // => true
   *
   * _.isNull(void 0);
   * // => false
   */
  function isNull(value) {
    return value === null;
  }

  /**
   * Checks if `value` is `null` or `undefined`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is nullish, else `false`.
   * @example
   *
   * _.isNil(null);
   * // => true
   *
   * _.isNil(void 0);
   * // => true
   *
   * _.isNil(NaN);
   * // => false
   */
  function isNil(value) {
    return value == null;
  }

  /**
   * Checks if `value` is classified as a `Number` primitive or object.
   *
   * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are
   * classified as numbers, use the `_.isFinite` method.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a number, else `false`.
   * @example
   *
   * _.isNumber(3);
   * // => true
   *
   * _.isNumber(Number.MIN_VALUE);
   * // => true
   *
   * _.isNumber(Infinity);
   * // => true
   *
   * _.isNumber('3');
   * // => false
   */
  function isNumber(value) {
    return typeof value == 'number' ||
      (isObjectLike(value) && baseGetTag(value) == numberTag);
  }

  /**
   * Checks if `value` is a plain object, that is, an object created by the
   * `Object` constructor or one with a `[[Prototype]]` of `null`.
   *
   * @static
   * @memberOf _
   * @since 0.8.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   * }
   *
   * _.isPlainObject(new Foo);
   * // => false
   *
   * _.isPlainObject([1, 2, 3]);
   * // => false
   *
   * _.isPlainObject({ 'x': 0, 'y': 0 });
   * // => true
   *
   * _.isPlainObject(Object.create(null));
   * // => true
   */
  function isPlainObject(value) {
    if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
      return false;
    }
    var proto = getPrototype(value);
    if (proto === null) {
      return true;
    }
    var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
    return typeof Ctor == 'function' && Ctor instanceof Ctor &&
      funcToString.call(Ctor) == objectCtorString;
  }

  /**
   * Checks if `value` is classified as a `RegExp` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
   * @example
   *
   * _.isRegExp(/abc/);
   * // => true
   *
   * _.isRegExp('/abc/');
   * // => false
   */
  var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;

  /**
   * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754
   * double precision number which isn't the result of a rounded unsafe integer.
   *
   * **Note:** This method is based on
   * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.
   * @example
   *
   * _.isSafeInteger(3);
   * // => true
   *
   * _.isSafeInteger(Number.MIN_VALUE);
   * // => false
   *
   * _.isSafeInteger(Infinity);
   * // => false
   *
   * _.isSafeInteger('3');
   * // => false
   */
  function isSafeInteger(value) {
    return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
  }

  /**
   * Checks if `value` is classified as a `Set` object.
   *
   * @static
   * @memberOf _
   * @since 4.3.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a set, else `false`.
   * @example
   *
   * _.isSet(new Set);
   * // => true
   *
   * _.isSet(new WeakSet);
   * // => false
   */
  var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;

  /**
   * Checks if `value` is classified as a `String` primitive or object.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a string, else `false`.
   * @example
   *
   * _.isString('abc');
   * // => true
   *
   * _.isString(1);
   * // => false
   */
  function isString(value) {
    return typeof value == 'string' ||
      (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);
  }

  /**
   * Checks if `value` is classified as a `Symbol` primitive or object.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
   * @example
   *
   * _.isSymbol(Symbol.iterator);
   * // => true
   *
   * _.isSymbol('abc');
   * // => false
   */
  function isSymbol(value) {
    return typeof value == 'symbol' ||
      (isObjectLike(value) && baseGetTag(value) == symbolTag);
  }

  /**
   * Checks if `value` is classified as a typed array.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
   * @example
   *
   * _.isTypedArray(new Uint8Array);
   * // => true
   *
   * _.isTypedArray([]);
   * // => false
   */
  var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;

  /**
   * Checks if `value` is `undefined`.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
   * @example
   *
   * _.isUndefined(void 0);
   * // => true
   *
   * _.isUndefined(null);
   * // => false
   */
  function isUndefined(value) {
    return value === undefined;
  }

  /**
   * Checks if `value` is classified as a `WeakMap` object.
   *
   * @static
   * @memberOf _
   * @since 4.3.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.
   * @example
   *
   * _.isWeakMap(new WeakMap);
   * // => true
   *
   * _.isWeakMap(new Map);
   * // => false
   */
  function isWeakMap(value) {
    return isObjectLike(value) && getTag(value) == weakMapTag;
  }

  /**
   * Checks if `value` is classified as a `WeakSet` object.
   *
   * @static
   * @memberOf _
   * @since 4.3.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.
   * @example
   *
   * _.isWeakSet(new WeakSet);
   * // => true
   *
   * _.isWeakSet(new Set);
   * // => false
   */
  function isWeakSet(value) {
    return isObjectLike(value) && baseGetTag(value) == weakSetTag;
  }

  /**
   * Checks if `value` is less than `other`.
   *
   * @static
   * @memberOf _
   * @since 3.9.0
   * @category Lang
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {boolean} Returns `true` if `value` is less than `other`,
   *  else `false`.
   * @see _.gt
   * @example
   *
   * _.lt(1, 3);
   * // => true
   *
   * _.lt(3, 3);
   * // => false
   *
   * _.lt(3, 1);
   * // => false
   */
  var lt = createRelationalOperation(baseLt);

  /**
   * Checks if `value` is less than or equal to `other`.
   *
   * @static
   * @memberOf _
   * @since 3.9.0
   * @category Lang
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {boolean} Returns `true` if `value` is less than or equal to
   *  `other`, else `false`.
   * @see _.gte
   * @example
   *
   * _.lte(1, 3);
   * // => true
   *
   * _.lte(3, 3);
   * // => true
   *
   * _.lte(3, 1);
   * // => false
   */
  var lte = createRelationalOperation(function(value, other) {
    return value <= other;
  });

  /**
   * Converts `value` to an array.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Lang
   * @param {*} value The value to convert.
   * @returns {Array} Returns the converted array.
   * @example
   *
   * _.toArray({ 'a': 1, 'b': 2 });
   * // => [1, 2]
   *
   * _.toArray('abc');
   * // => ['a', 'b', 'c']
   *
   * _.toArray(1);
   * // => []
   *
   * _.toArray(null);
   * // => []
   */
  function toArray(value) {
    if (!value) {
      return [];
    }
    if (isArrayLike(value)) {
      return isString(value) ? stringToArray(value) : copyArray(value);
    }
    if (symIterator && value[symIterator]) {
      return iteratorToArray(value[symIterator]());
    }
    var tag = getTag(value),
        func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);

    return func(value);
  }

  /**
   * Converts `value` to a finite number.
   *
   * @static
   * @memberOf _
   * @since 4.12.0
   * @category Lang
   * @param {*} value The value to convert.
   * @returns {number} Returns the converted number.
   * @example
   *
   * _.toFinite(3.2);
   * // => 3.2
   *
   * _.toFinite(Number.MIN_VALUE);
   * // => 5e-324
   *
   * _.toFinite(Infinity);
   * // => 1.7976931348623157e+308
   *
   * _.toFinite('3.2');
   * // => 3.2
   */
  function toFinite(value) {
    if (!value) {
      return value === 0 ? value : 0;
    }
    value = toNumber(value);
    if (value === INFINITY || value === -INFINITY) {
      var sign = (value < 0 ? -1 : 1);
      return sign * MAX_INTEGER;
    }
    return value === value ? value : 0;
  }

  /**
   * Converts `value` to an integer.
   *
   * **Note:** This method is loosely based on
   * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to convert.
   * @returns {number} Returns the converted integer.
   * @example
   *
   * _.toInteger(3.2);
   * // => 3
   *
   * _.toInteger(Number.MIN_VALUE);
   * // => 0
   *
   * _.toInteger(Infinity);
   * // => 1.7976931348623157e+308
   *
   * _.toInteger('3.2');
   * // => 3
   */
  function toInteger(value) {
    var result = toFinite(value),
        remainder = result % 1;

    return result === result ? (remainder ? result - remainder : result) : 0;
  }

  /**
   * Converts `value` to an integer suitable for use as the length of an
   * array-like object.
   *
   * **Note:** This method is based on
   * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to convert.
   * @returns {number} Returns the converted integer.
   * @example
   *
   * _.toLength(3.2);
   * // => 3
   *
   * _.toLength(Number.MIN_VALUE);
   * // => 0
   *
   * _.toLength(Infinity);
   * // => 4294967295
   *
   * _.toLength('3.2');
   * // => 3
   */
  function toLength(value) {
    return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
  }

  /**
   * Converts `value` to a number.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to process.
   * @returns {number} Returns the number.
   * @example
   *
   * _.toNumber(3.2);
   * // => 3.2
   *
   * _.toNumber(Number.MIN_VALUE);
   * // => 5e-324
   *
   * _.toNumber(Infinity);
   * // => Infinity
   *
   * _.toNumber('3.2');
   * // => 3.2
   */
  function toNumber(value) {
    if (typeof value == 'number') {
      return value;
    }
    if (isSymbol(value)) {
      return NAN;
    }
    if (isObject(value)) {
      var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
      value = isObject(other) ? (other + '') : other;
    }
    if (typeof value != 'string') {
      return value === 0 ? value : +value;
    }
    value = value.replace(reTrim, '');
    var isBinary = reIsBinary.test(value);
    return (isBinary || reIsOctal.test(value))
      ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
      : (reIsBadHex.test(value) ? NAN : +value);
  }

  /**
   * Converts `value` to a plain object flattening inherited enumerable string
   * keyed properties of `value` to own properties of the plain object.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Lang
   * @param {*} value The value to convert.
   * @returns {Object} Returns the converted plain object.
   * @example
   *
   * function Foo() {
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.assign({ 'a': 1 }, new Foo);
   * // => { 'a': 1, 'b': 2 }
   *
   * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
   * // => { 'a': 1, 'b': 2, 'c': 3 }
   */
  function toPlainObject(value) {
    return copyObject(value, keysIn(value));
  }

  /**
   * Converts `value` to a safe integer. A safe integer can be compared and
   * represented correctly.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to convert.
   * @returns {number} Returns the converted integer.
   * @example
   *
   * _.toSafeInteger(3.2);
   * // => 3
   *
   * _.toSafeInteger(Number.MIN_VALUE);
   * // => 0
   *
   * _.toSafeInteger(Infinity);
   * // => 9007199254740991
   *
   * _.toSafeInteger('3.2');
   * // => 3
   */
  function toSafeInteger(value) {
    return value
      ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)
      : (value === 0 ? value : 0);
  }

  /**
   * Converts `value` to a string. An empty string is returned for `null`
   * and `undefined` values. The sign of `-0` is preserved.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to convert.
   * @returns {string} Returns the converted string.
   * @example
   *
   * _.toString(null);
   * // => ''
   *
   * _.toString(-0);
   * // => '-0'
   *
   * _.toString([1, 2, 3]);
   * // => '1,2,3'
   */
  function toString(value) {
    return value == null ? '' : baseToString(value);
  }

  /*------------------------------------------------------------------------*/

  /**
   * Assigns own enumerable string keyed properties of source objects to the
   * destination object. Source objects are applied from left to right.
   * Subsequent sources overwrite property assignments of previous sources.
   *
   * **Note:** This method mutates `object` and is loosely based on
   * [`Object.assign`](https://mdn.io/Object/assign).
   *
   * @static
   * @memberOf _
   * @since 0.10.0
   * @category Object
   * @param {Object} object The destination object.
   * @param {...Object} [sources] The source objects.
   * @returns {Object} Returns `object`.
   * @see _.assignIn
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   * }
   *
   * function Bar() {
   *   this.c = 3;
   * }
   *
   * Foo.prototype.b = 2;
   * Bar.prototype.d = 4;
   *
   * _.assign({ 'a': 0 }, new Foo, new Bar);
   * // => { 'a': 1, 'c': 3 }
   */
  var assign = createAssigner(function(object, source) {
    if (isPrototype(source) || isArrayLike(source)) {
      copyObject(source, keys(source), object);
      return;
    }
    for (var key in source) {
      if (hasOwnProperty.call(source, key)) {
        assignValue(object, key, source[key]);
      }
    }
  });

  /**
   * This method is like `_.assign` except that it iterates over own and
   * inherited source properties.
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @alias extend
   * @category Object
   * @param {Object} object The destination object.
   * @param {...Object} [sources] The source objects.
   * @returns {Object} Returns `object`.
   * @see _.assign
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   * }
   *
   * function Bar() {
   *   this.c = 3;
   * }
   *
   * Foo.prototype.b = 2;
   * Bar.prototype.d = 4;
   *
   * _.assignIn({ 'a': 0 }, new Foo, new Bar);
   * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }
   */
  var assignIn = createAssigner(function(object, source) {
    copyObject(source, keysIn(source), object);
  });

  /**
   * This method is like `_.assignIn` except that it accepts `customizer`
   * which is invoked to produce the assigned values. If `customizer` returns
   * `undefined`, assignment is handled by the method instead. The `customizer`
   * is invoked with five arguments: (objValue, srcValue, key, object, source).
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @alias extendWith
   * @category Object
   * @param {Object} object The destination object.
   * @param {...Object} sources The source objects.
   * @param {Function} [customizer] The function to customize assigned values.
   * @returns {Object} Returns `object`.
   * @see _.assignWith
   * @example
   *
   * function customizer(objValue, srcValue) {
   *   return _.isUndefined(objValue) ? srcValue : objValue;
   * }
   *
   * var defaults = _.partialRight(_.assignInWith, customizer);
   *
   * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
   * // => { 'a': 1, 'b': 2 }
   */
  var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
    copyObject(source, keysIn(source), object, customizer);
  });

  /**
   * This method is like `_.assign` except that it accepts `customizer`
   * which is invoked to produce the assigned values. If `customizer` returns
   * `undefined`, assignment is handled by the method instead. The `customizer`
   * is invoked with five arguments: (objValue, srcValue, key, object, source).
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Object
   * @param {Object} object The destination object.
   * @param {...Object} sources The source objects.
   * @param {Function} [customizer] The function to customize assigned values.
   * @returns {Object} Returns `object`.
   * @see _.assignInWith
   * @example
   *
   * function customizer(objValue, srcValue) {
   *   return _.isUndefined(objValue) ? srcValue : objValue;
   * }
   *
   * var defaults = _.partialRight(_.assignWith, customizer);
   *
   * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
   * // => { 'a': 1, 'b': 2 }
   */
  var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
    copyObject(source, keys(source), object, customizer);
  });

  /**
   * Creates an array of values corresponding to `paths` of `object`.
   *
   * @static
   * @memberOf _
   * @since 1.0.0
   * @category Object
   * @param {Object} object The object to iterate over.
   * @param {...(string|string[])} [paths] The property paths to pick.
   * @returns {Array} Returns the picked values.
   * @example
   *
   * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
   *
   * _.at(object, ['a[0].b.c', 'a[1]']);
   * // => [3, 4]
   */
  var at = flatRest(baseAt);

  /**
   * Creates an object that inherits from the `prototype` object. If a
   * `properties` object is given, its own enumerable string keyed properties
   * are assigned to the created object.
   *
   * @static
   * @memberOf _
   * @since 2.3.0
   * @category Object
   * @param {Object} prototype The object to inherit from.
   * @param {Object} [properties] The properties to assign to the object.
   * @returns {Object} Returns the new object.
   * @example
   *
   * function Shape() {
   *   this.x = 0;
   *   this.y = 0;
   * }
   *
   * function Circle() {
   *   Shape.call(this);
   * }
   *
   * Circle.prototype = _.create(Shape.prototype, {
   *   'constructor': Circle
   * });
   *
   * var circle = new Circle;
   * circle instanceof Circle;
   * // => true
   *
   * circle instanceof Shape;
   * // => true
   */
  function create(prototype, properties) {
    var result = baseCreate(prototype);
    return properties == null ? result : baseAssign(result, properties);
  }

  /**
   * Assigns own and inherited enumerable string keyed properties of source
   * objects to the destination object for all destination properties that
   * resolve to `undefined`. Source objects are applied from left to right.
   * Once a property is set, additional values of the same property are ignored.
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Object
   * @param {Object} object The destination object.
   * @param {...Object} [sources] The source objects.
   * @returns {Object} Returns `object`.
   * @see _.defaultsDeep
   * @example
   *
   * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
   * // => { 'a': 1, 'b': 2 }
   */
  var defaults = baseRest(function(args) {
    args.push(undefined, customDefaultsAssignIn);
    return apply(assignInWith, undefined, args);
  });

  /**
   * This method is like `_.defaults` except that it recursively assigns
   * default properties.
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @memberOf _
   * @since 3.10.0
   * @category Object
   * @param {Object} object The destination object.
   * @param {...Object} [sources] The source objects.
   * @returns {Object} Returns `object`.
   * @see _.defaults
   * @example
   *
   * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });
   * // => { 'a': { 'b': 2, 'c': 3 } }
   */
  var defaultsDeep = baseRest(function(args) {
    args.push(undefined, customDefaultsMerge);
    return apply(mergeWith, undefined, args);
  });

  /**
   * This method is like `_.find` except that it returns the key of the first
   * element `predicate` returns truthy for instead of the element itself.
   *
   * @static
   * @memberOf _
   * @since 1.1.0
   * @category Object
   * @param {Object} object The object to inspect.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @returns {string|undefined} Returns the key of the matched element,
   *  else `undefined`.
   * @example
   *
   * var users = {
   *   'barney':  { 'age': 36, 'active': true },
   *   'fred':    { 'age': 40, 'active': false },
   *   'pebbles': { 'age': 1,  'active': true }
   * };
   *
   * _.findKey(users, function(o) { return o.age < 40; });
   * // => 'barney' (iteration order is not guaranteed)
   *
   * // The `_.matches` iteratee shorthand.
   * _.findKey(users, { 'age': 1, 'active': true });
   * // => 'pebbles'
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.findKey(users, ['active', false]);
   * // => 'fred'
   *
   * // The `_.property` iteratee shorthand.
   * _.findKey(users, 'active');
   * // => 'barney'
   */
  function findKey(object, predicate) {
    return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);
  }

  /**
   * This method is like `_.findKey` except that it iterates over elements of
   * a collection in the opposite order.
   *
   * @static
   * @memberOf _
   * @since 2.0.0
   * @category Object
   * @param {Object} object The object to inspect.
   * @param {Function} [predicate=_.identity] The function invoked per iteration.
   * @returns {string|undefined} Returns the key of the matched element,
   *  else `undefined`.
   * @example
   *
   * var users = {
   *   'barney':  { 'age': 36, 'active': true },
   *   'fred':    { 'age': 40, 'active': false },
   *   'pebbles': { 'age': 1,  'active': true }
   * };
   *
   * _.findLastKey(users, function(o) { return o.age < 40; });
   * // => returns 'pebbles' assuming `_.findKey` returns 'barney'
   *
   * // The `_.matches` iteratee shorthand.
   * _.findLastKey(users, { 'age': 36, 'active': true });
   * // => 'barney'
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.findLastKey(users, ['active', false]);
   * // => 'fred'
   *
   * // The `_.property` iteratee shorthand.
   * _.findLastKey(users, 'active');
   * // => 'pebbles'
   */
  function findLastKey(object, predicate) {
    return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
  }

  /**
   * Iterates over own and inherited enumerable string keyed properties of an
   * object and invokes `iteratee` for each property. The iteratee is invoked
   * with three arguments: (value, key, object). Iteratee functions may exit
   * iteration early by explicitly returning `false`.
   *
   * @static
   * @memberOf _
   * @since 0.3.0
   * @category Object
   * @param {Object} object The object to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Object} Returns `object`.
   * @see _.forInRight
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.forIn(new Foo, function(value, key) {
   *   console.log(key);
   * });
   * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).
   */
  function forIn(object, iteratee) {
    return object == null
      ? object
      : baseFor(object, getIteratee(iteratee, 3), keysIn);
  }

  /**
   * This method is like `_.forIn` except that it iterates over properties of
   * `object` in the opposite order.
   *
   * @static
   * @memberOf _
   * @since 2.0.0
   * @category Object
   * @param {Object} object The object to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Object} Returns `object`.
   * @see _.forIn
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.forInRight(new Foo, function(value, key) {
   *   console.log(key);
   * });
   * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.
   */
  function forInRight(object, iteratee) {
    return object == null
      ? object
      : baseForRight(object, getIteratee(iteratee, 3), keysIn);
  }

  /**
   * Iterates over own enumerable string keyed properties of an object and
   * invokes `iteratee` for each property. The iteratee is invoked with three
   * arguments: (value, key, object). Iteratee functions may exit iteration
   * early by explicitly returning `false`.
   *
   * @static
   * @memberOf _
   * @since 0.3.0
   * @category Object
   * @param {Object} object The object to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Object} Returns `object`.
   * @see _.forOwnRight
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.forOwn(new Foo, function(value, key) {
   *   console.log(key);
   * });
   * // => Logs 'a' then 'b' (iteration order is not guaranteed).
   */
  function forOwn(object, iteratee) {
    return object && baseForOwn(object, getIteratee(iteratee, 3));
  }

  /**
   * This method is like `_.forOwn` except that it iterates over properties of
   * `object` in the opposite order.
   *
   * @static
   * @memberOf _
   * @since 2.0.0
   * @category Object
   * @param {Object} object The object to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Object} Returns `object`.
   * @see _.forOwn
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.forOwnRight(new Foo, function(value, key) {
   *   console.log(key);
   * });
   * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.
   */
  function forOwnRight(object, iteratee) {
    return object && baseForOwnRight(object, getIteratee(iteratee, 3));
  }

  /**
   * Creates an array of function property names from own enumerable properties
   * of `object`.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Object
   * @param {Object} object The object to inspect.
   * @returns {Array} Returns the function names.
   * @see _.functionsIn
   * @example
   *
   * function Foo() {
   *   this.a = _.constant('a');
   *   this.b = _.constant('b');
   * }
   *
   * Foo.prototype.c = _.constant('c');
   *
   * _.functions(new Foo);
   * // => ['a', 'b']
   */
  function functions(object) {
    return object == null ? [] : baseFunctions(object, keys(object));
  }

  /**
   * Creates an array of function property names from own and inherited
   * enumerable properties of `object`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Object
   * @param {Object} object The object to inspect.
   * @returns {Array} Returns the function names.
   * @see _.functions
   * @example
   *
   * function Foo() {
   *   this.a = _.constant('a');
   *   this.b = _.constant('b');
   * }
   *
   * Foo.prototype.c = _.constant('c');
   *
   * _.functionsIn(new Foo);
   * // => ['a', 'b', 'c']
   */
  function functionsIn(object) {
    return object == null ? [] : baseFunctions(object, keysIn(object));
  }

  /**
   * Gets the value at `path` of `object`. If the resolved value is
   * `undefined`, the `defaultValue` is returned in its place.
   *
   * @static
   * @memberOf _
   * @since 3.7.0
   * @category Object
   * @param {Object} object The object to query.
   * @param {Array|string} path The path of the property to get.
   * @param {*} [defaultValue] The value returned for `undefined` resolved values.
   * @returns {*} Returns the resolved value.
   * @example
   *
   * var object = { 'a': [{ 'b': { 'c': 3 } }] };
   *
   * _.get(object, 'a[0].b.c');
   * // => 3
   *
   * _.get(object, ['a', '0', 'b', 'c']);
   * // => 3
   *
   * _.get(object, 'a.b.c', 'default');
   * // => 'default'
   */
  function get(object, path, defaultValue) {
    var result = object == null ? undefined : baseGet(object, path);
    return result === undefined ? defaultValue : result;
  }

  /**
   * Checks if `path` is a direct property of `object`.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Object
   * @param {Object} object The object to query.
   * @param {Array|string} path The path to check.
   * @returns {boolean} Returns `true` if `path` exists, else `false`.
   * @example
   *
   * var object = { 'a': { 'b': 2 } };
   * var other = _.create({ 'a': _.create({ 'b': 2 }) });
   *
   * _.has(object, 'a');
   * // => true
   *
   * _.has(object, 'a.b');
   * // => true
   *
   * _.has(object, ['a', 'b']);
   * // => true
   *
   * _.has(other, 'a');
   * // => false
   */
  function has(object, path) {
    return object != null && hasPath(object, path, baseHas);
  }

  /**
   * Checks if `path` is a direct or inherited property of `object`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Object
   * @param {Object} object The object to query.
   * @param {Array|string} path The path to check.
   * @returns {boolean} Returns `true` if `path` exists, else `false`.
   * @example
   *
   * var object = _.create({ 'a': _.create({ 'b': 2 }) });
   *
   * _.hasIn(object, 'a');
   * // => true
   *
   * _.hasIn(object, 'a.b');
   * // => true
   *
   * _.hasIn(object, ['a', 'b']);
   * // => true
   *
   * _.hasIn(object, 'b');
   * // => false
   */
  function hasIn(object, path) {
    return object != null && hasPath(object, path, baseHasIn);
  }

  /**
   * Creates an object composed of the inverted keys and values of `object`.
   * If `object` contains duplicate values, subsequent values overwrite
   * property assignments of previous values.
   *
   * @static
   * @memberOf _
   * @since 0.7.0
   * @category Object
   * @param {Object} object The object to invert.
   * @returns {Object} Returns the new inverted object.
   * @example
   *
   * var object = { 'a': 1, 'b': 2, 'c': 1 };
   *
   * _.invert(object);
   * // => { '1': 'c', '2': 'b' }
   */
  var invert = createInverter(function(result, value, key) {
    result[value] = key;
  }, constant(identity));

  /**
   * This method is like `_.invert` except that the inverted object is generated
   * from the results of running each element of `object` thru `iteratee`. The
   * corresponding inverted value of each inverted key is an array of keys
   * responsible for generating the inverted value. The iteratee is invoked
   * with one argument: (value).
   *
   * @static
   * @memberOf _
   * @since 4.1.0
   * @category Object
   * @param {Object} object The object to invert.
   * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
   * @returns {Object} Returns the new inverted object.
   * @example
   *
   * var object = { 'a': 1, 'b': 2, 'c': 1 };
   *
   * _.invertBy(object);
   * // => { '1': ['a', 'c'], '2': ['b'] }
   *
   * _.invertBy(object, function(value) {
   *   return 'group' + value;
   * });
   * // => { 'group1': ['a', 'c'], 'group2': ['b'] }
   */
  var invertBy = createInverter(function(result, value, key) {
    if (hasOwnProperty.call(result, value)) {
      result[value].push(key);
    } else {
      result[value] = [key];
    }
  }, getIteratee);

  /**
   * Invokes the method at `path` of `object`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Object
   * @param {Object} object The object to query.
   * @param {Array|string} path The path of the method to invoke.
   * @param {...*} [args] The arguments to invoke the method with.
   * @returns {*} Returns the result of the invoked method.
   * @example
   *
   * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };
   *
   * _.invoke(object, 'a[0].b.c.slice', 1, 3);
   * // => [2, 3]
   */
  var invoke = baseRest(baseInvoke);

  /**
   * Creates an array of the own enumerable property names of `object`.
   *
   * **Note:** Non-object values are coerced to objects. See the
   * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
   * for more details.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Object
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.keys(new Foo);
   * // => ['a', 'b'] (iteration order is not guaranteed)
   *
   * _.keys('hi');
   * // => ['0', '1']
   */
  function keys(object) {
    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
  }

  /**
   * Creates an array of the own and inherited enumerable property names of `object`.
   *
   * **Note:** Non-object values are coerced to objects.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Object
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.keysIn(new Foo);
   * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
   */
  function keysIn(object) {
    return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
  }

  /**
   * The opposite of `_.mapValues`; this method creates an object with the
   * same values as `object` and keys generated by running each own enumerable
   * string keyed property of `object` thru `iteratee`. The iteratee is invoked
   * with three arguments: (value, key, object).
   *
   * @static
   * @memberOf _
   * @since 3.8.0
   * @category Object
   * @param {Object} object The object to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Object} Returns the new mapped object.
   * @see _.mapValues
   * @example
   *
   * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
   *   return key + value;
   * });
   * // => { 'a1': 1, 'b2': 2 }
   */
  function mapKeys(object, iteratee) {
    var result = {};
    iteratee = getIteratee(iteratee, 3);

    baseForOwn(object, function(value, key, object) {
      baseAssignValue(result, iteratee(value, key, object), value);
    });
    return result;
  }

  /**
   * Creates an object with the same keys as `object` and values generated
   * by running each own enumerable string keyed property of `object` thru
   * `iteratee`. The iteratee is invoked with three arguments:
   * (value, key, object).
   *
   * @static
   * @memberOf _
   * @since 2.4.0
   * @category Object
   * @param {Object} object The object to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Object} Returns the new mapped object.
   * @see _.mapKeys
   * @example
   *
   * var users = {
   *   'fred':    { 'user': 'fred',    'age': 40 },
   *   'pebbles': { 'user': 'pebbles', 'age': 1 }
   * };
   *
   * _.mapValues(users, function(o) { return o.age; });
   * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
   *
   * // The `_.property` iteratee shorthand.
   * _.mapValues(users, 'age');
   * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
   */
  function mapValues(object, iteratee) {
    var result = {};
    iteratee = getIteratee(iteratee, 3);

    baseForOwn(object, function(value, key, object) {
      baseAssignValue(result, key, iteratee(value, key, object));
    });
    return result;
  }

  /**
   * This method is like `_.assign` except that it recursively merges own and
   * inherited enumerable string keyed properties of source objects into the
   * destination object. Source properties that resolve to `undefined` are
   * skipped if a destination value exists. Array and plain object properties
   * are merged recursively. Other objects and value types are overridden by
   * assignment. Source objects are applied from left to right. Subsequent
   * sources overwrite property assignments of previous sources.
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @memberOf _
   * @since 0.5.0
   * @category Object
   * @param {Object} object The destination object.
   * @param {...Object} [sources] The source objects.
   * @returns {Object} Returns `object`.
   * @example
   *
   * var object = {
   *   'a': [{ 'b': 2 }, { 'd': 4 }]
   * };
   *
   * var other = {
   *   'a': [{ 'c': 3 }, { 'e': 5 }]
   * };
   *
   * _.merge(object, other);
   * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
   */
  var merge = createAssigner(function(object, source, srcIndex) {
    baseMerge(object, source, srcIndex);
  });

  /**
   * This method is like `_.merge` except that it accepts `customizer` which
   * is invoked to produce the merged values of the destination and source
   * properties. If `customizer` returns `undefined`, merging is handled by the
   * method instead. The `customizer` is invoked with six arguments:
   * (objValue, srcValue, key, object, source, stack).
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Object
   * @param {Object} object The destination object.
   * @param {...Object} sources The source objects.
   * @param {Function} customizer The function to customize assigned values.
   * @returns {Object} Returns `object`.
   * @example
   *
   * function customizer(objValue, srcValue) {
   *   if (_.isArray(objValue)) {
   *     return objValue.concat(srcValue);
   *   }
   * }
   *
   * var object = { 'a': [1], 'b': [2] };
   * var other = { 'a': [3], 'b': [4] };
   *
   * _.mergeWith(object, other, customizer);
   * // => { 'a': [1, 3], 'b': [2, 4] }
   */
  var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
    baseMerge(object, source, srcIndex, customizer);
  });

  /**
   * The opposite of `_.pick`; this method creates an object composed of the
   * own and inherited enumerable property paths of `object` that are not omitted.
   *
   * **Note:** This method is considerably slower than `_.pick`.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Object
   * @param {Object} object The source object.
   * @param {...(string|string[])} [paths] The property paths to omit.
   * @returns {Object} Returns the new object.
   * @example
   *
   * var object = { 'a': 1, 'b': '2', 'c': 3 };
   *
   * _.omit(object, ['a', 'c']);
   * // => { 'b': '2' }
   */
  var omit = flatRest(function(object, paths) {
    var result = {};
    if (object == null) {
      return result;
    }
    var isDeep = false;
    paths = arrayMap(paths, function(path) {
      path = castPath(path, object);
      isDeep || (isDeep = path.length > 1);
      return path;
    });
    copyObject(object, getAllKeysIn(object), result);
    if (isDeep) {
      result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
    }
    var length = paths.length;
    while (length--) {
      baseUnset(result, paths[length]);
    }
    return result;
  });

  /**
   * The opposite of `_.pickBy`; this method creates an object composed of
   * the own and inherited enumerable string keyed properties of `object` that
   * `predicate` doesn't return truthy for. The predicate is invoked with two
   * arguments: (value, key).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Object
   * @param {Object} object The source object.
   * @param {Function} [predicate=_.identity] The function invoked per property.
   * @returns {Object} Returns the new object.
   * @example
   *
   * var object = { 'a': 1, 'b': '2', 'c': 3 };
   *
   * _.omitBy(object, _.isNumber);
   * // => { 'b': '2' }
   */
  function omitBy(object, predicate) {
    return pickBy(object, negate(getIteratee(predicate)));
  }

  /**
   * Creates an object composed of the picked `object` properties.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Object
   * @param {Object} object The source object.
   * @param {...(string|string[])} [paths] The property paths to pick.
   * @returns {Object} Returns the new object.
   * @example
   *
   * var object = { 'a': 1, 'b': '2', 'c': 3 };
   *
   * _.pick(object, ['a', 'c']);
   * // => { 'a': 1, 'c': 3 }
   */
  var pick = flatRest(function(object, paths) {
    return object == null ? {} : basePick(object, paths);
  });

  /**
   * Creates an object composed of the `object` properties `predicate` returns
   * truthy for. The predicate is invoked with two arguments: (value, key).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Object
   * @param {Object} object The source object.
   * @param {Function} [predicate=_.identity] The function invoked per property.
   * @returns {Object} Returns the new object.
   * @example
   *
   * var object = { 'a': 1, 'b': '2', 'c': 3 };
   *
   * _.pickBy(object, _.isNumber);
   * // => { 'a': 1, 'c': 3 }
   */
  function pickBy(object, predicate) {
    if (object == null) {
      return {};
    }
    var props = arrayMap(getAllKeysIn(object), function(prop) {
      return [prop];
    });
    predicate = getIteratee(predicate);
    return basePickBy(object, props, function(value, path) {
      return predicate(value, path[0]);
    });
  }

  /**
   * This method is like `_.get` except that if the resolved value is a
   * function it's invoked with the `this` binding of its parent object and
   * its result is returned.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Object
   * @param {Object} object The object to query.
   * @param {Array|string} path The path of the property to resolve.
   * @param {*} [defaultValue] The value returned for `undefined` resolved values.
   * @returns {*} Returns the resolved value.
   * @example
   *
   * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };
   *
   * _.result(object, 'a[0].b.c1');
   * // => 3
   *
   * _.result(object, 'a[0].b.c2');
   * // => 4
   *
   * _.result(object, 'a[0].b.c3', 'default');
   * // => 'default'
   *
   * _.result(object, 'a[0].b.c3', _.constant('default'));
   * // => 'default'
   */
  function result(object, path, defaultValue) {
    path = castPath(path, object);

    var index = -1,
        length = path.length;

    // Ensure the loop is entered when path is empty.
    if (!length) {
      length = 1;
      object = undefined;
    }
    while (++index < length) {
      var value = object == null ? undefined : object[toKey(path[index])];
      if (value === undefined) {
        index = length;
        value = defaultValue;
      }
      object = isFunction(value) ? value.call(object) : value;
    }
    return object;
  }

  /**
   * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
   * it's created. Arrays are created for missing index properties while objects
   * are created for all other missing properties. Use `_.setWith` to customize
   * `path` creation.
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @memberOf _
   * @since 3.7.0
   * @category Object
   * @param {Object} object The object to modify.
   * @param {Array|string} path The path of the property to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns `object`.
   * @example
   *
   * var object = { 'a': [{ 'b': { 'c': 3 } }] };
   *
   * _.set(object, 'a[0].b.c', 4);
   * console.log(object.a[0].b.c);
   * // => 4
   *
   * _.set(object, ['x', '0', 'y', 'z'], 5);
   * console.log(object.x[0].y.z);
   * // => 5
   */
  function set(object, path, value) {
    return object == null ? object : baseSet(object, path, value);
  }

  /**
   * This method is like `_.set` except that it accepts `customizer` which is
   * invoked to produce the objects of `path`.  If `customizer` returns `undefined`
   * path creation is handled by the method instead. The `customizer` is invoked
   * with three arguments: (nsValue, key, nsObject).
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Object
   * @param {Object} object The object to modify.
   * @param {Array|string} path The path of the property to set.
   * @param {*} value The value to set.
   * @param {Function} [customizer] The function to customize assigned values.
   * @returns {Object} Returns `object`.
   * @example
   *
   * var object = {};
   *
   * _.setWith(object, '[0][1]', 'a', Object);
   * // => { '0': { '1': 'a' } }
   */
  function setWith(object, path, value, customizer) {
    customizer = typeof customizer == 'function' ? customizer : undefined;
    return object == null ? object : baseSet(object, path, value, customizer);
  }

  /**
   * Creates an array of own enumerable string keyed-value pairs for `object`
   * which can be consumed by `_.fromPairs`. If `object` is a map or set, its
   * entries are returned.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @alias entries
   * @category Object
   * @param {Object} object The object to query.
   * @returns {Array} Returns the key-value pairs.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.toPairs(new Foo);
   * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)
   */
  var toPairs = createToPairs(keys);

  /**
   * Creates an array of own and inherited enumerable string keyed-value pairs
   * for `object` which can be consumed by `_.fromPairs`. If `object` is a map
   * or set, its entries are returned.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @alias entriesIn
   * @category Object
   * @param {Object} object The object to query.
   * @returns {Array} Returns the key-value pairs.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.toPairsIn(new Foo);
   * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)
   */
  var toPairsIn = createToPairs(keysIn);

  /**
   * An alternative to `_.reduce`; this method transforms `object` to a new
   * `accumulator` object which is the result of running each of its own
   * enumerable string keyed properties thru `iteratee`, with each invocation
   * potentially mutating the `accumulator` object. If `accumulator` is not
   * provided, a new object with the same `[[Prototype]]` will be used. The
   * iteratee is invoked with four arguments: (accumulator, value, key, object).
   * Iteratee functions may exit iteration early by explicitly returning `false`.
   *
   * @static
   * @memberOf _
   * @since 1.3.0
   * @category Object
   * @param {Object} object The object to iterate over.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @param {*} [accumulator] The custom accumulator value.
   * @returns {*} Returns the accumulated value.
   * @example
   *
   * _.transform([2, 3, 4], function(result, n) {
   *   result.push(n *= n);
   *   return n % 2 == 0;
   * }, []);
   * // => [4, 9]
   *
   * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
   *   (result[value] || (result[value] = [])).push(key);
   * }, {});
   * // => { '1': ['a', 'c'], '2': ['b'] }
   */
  function transform(object, iteratee, accumulator) {
    var isArr = isArray(object),
        isArrLike = isArr || isBuffer(object) || isTypedArray(object);

    iteratee = getIteratee(iteratee, 4);
    if (accumulator == null) {
      var Ctor = object && object.constructor;
      if (isArrLike) {
        accumulator = isArr ? new Ctor : [];
      }
      else if (isObject(object)) {
        accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};
      }
      else {
        accumulator = {};
      }
    }
    (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {
      return iteratee(accumulator, value, index, object);
    });
    return accumulator;
  }

  /**
   * Removes the property at `path` of `object`.
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Object
   * @param {Object} object The object to modify.
   * @param {Array|string} path The path of the property to unset.
   * @returns {boolean} Returns `true` if the property is deleted, else `false`.
   * @example
   *
   * var object = { 'a': [{ 'b': { 'c': 7 } }] };
   * _.unset(object, 'a[0].b.c');
   * // => true
   *
   * console.log(object);
   * // => { 'a': [{ 'b': {} }] };
   *
   * _.unset(object, ['a', '0', 'b', 'c']);
   * // => true
   *
   * console.log(object);
   * // => { 'a': [{ 'b': {} }] };
   */
  function unset(object, path) {
    return object == null ? true : baseUnset(object, path);
  }

  /**
   * This method is like `_.set` except that accepts `updater` to produce the
   * value to set. Use `_.updateWith` to customize `path` creation. The `updater`
   * is invoked with one argument: (value).
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @memberOf _
   * @since 4.6.0
   * @category Object
   * @param {Object} object The object to modify.
   * @param {Array|string} path The path of the property to set.
   * @param {Function} updater The function to produce the updated value.
   * @returns {Object} Returns `object`.
   * @example
   *
   * var object = { 'a': [{ 'b': { 'c': 3 } }] };
   *
   * _.update(object, 'a[0].b.c', function(n) { return n * n; });
   * console.log(object.a[0].b.c);
   * // => 9
   *
   * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });
   * console.log(object.x[0].y.z);
   * // => 0
   */
  function update(object, path, updater) {
    return object == null ? object : baseUpdate(object, path, castFunction(updater));
  }

  /**
   * This method is like `_.update` except that it accepts `customizer` which is
   * invoked to produce the objects of `path`.  If `customizer` returns `undefined`
   * path creation is handled by the method instead. The `customizer` is invoked
   * with three arguments: (nsValue, key, nsObject).
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @memberOf _
   * @since 4.6.0
   * @category Object
   * @param {Object} object The object to modify.
   * @param {Array|string} path The path of the property to set.
   * @param {Function} updater The function to produce the updated value.
   * @param {Function} [customizer] The function to customize assigned values.
   * @returns {Object} Returns `object`.
   * @example
   *
   * var object = {};
   *
   * _.updateWith(object, '[0][1]', _.constant('a'), Object);
   * // => { '0': { '1': 'a' } }
   */
  function updateWith(object, path, updater, customizer) {
    customizer = typeof customizer == 'function' ? customizer : undefined;
    return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
  }

  /**
   * Creates an array of the own enumerable string keyed property values of `object`.
   *
   * **Note:** Non-object values are coerced to objects.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Object
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property values.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.values(new Foo);
   * // => [1, 2] (iteration order is not guaranteed)
   *
   * _.values('hi');
   * // => ['h', 'i']
   */
  function values(object) {
    return object == null ? [] : baseValues(object, keys(object));
  }

  /**
   * Creates an array of the own and inherited enumerable string keyed property
   * values of `object`.
   *
   * **Note:** Non-object values are coerced to objects.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Object
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property values.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.valuesIn(new Foo);
   * // => [1, 2, 3] (iteration order is not guaranteed)
   */
  function valuesIn(object) {
    return object == null ? [] : baseValues(object, keysIn(object));
  }

  /*------------------------------------------------------------------------*/

  /**
   * Clamps `number` within the inclusive `lower` and `upper` bounds.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Number
   * @param {number} number The number to clamp.
   * @param {number} [lower] The lower bound.
   * @param {number} upper The upper bound.
   * @returns {number} Returns the clamped number.
   * @example
   *
   * _.clamp(-10, -5, 5);
   * // => -5
   *
   * _.clamp(10, -5, 5);
   * // => 5
   */
  function clamp(number, lower, upper) {
    if (upper === undefined) {
      upper = lower;
      lower = undefined;
    }
    if (upper !== undefined) {
      upper = toNumber(upper);
      upper = upper === upper ? upper : 0;
    }
    if (lower !== undefined) {
      lower = toNumber(lower);
      lower = lower === lower ? lower : 0;
    }
    return baseClamp(toNumber(number), lower, upper);
  }

  /**
   * Checks if `n` is between `start` and up to, but not including, `end`. If
   * `end` is not specified, it's set to `start` with `start` then set to `0`.
   * If `start` is greater than `end` the params are swapped to support
   * negative ranges.
   *
   * @static
   * @memberOf _
   * @since 3.3.0
   * @category Number
   * @param {number} number The number to check.
   * @param {number} [start=0] The start of the range.
   * @param {number} end The end of the range.
   * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
   * @see _.range, _.rangeRight
   * @example
   *
   * _.inRange(3, 2, 4);
   * // => true
   *
   * _.inRange(4, 8);
   * // => true
   *
   * _.inRange(4, 2);
   * // => false
   *
   * _.inRange(2, 2);
   * // => false
   *
   * _.inRange(1.2, 2);
   * // => true
   *
   * _.inRange(5.2, 4);
   * // => false
   *
   * _.inRange(-3, -2, -6);
   * // => true
   */
  function inRange(number, start, end) {
    start = toFinite(start);
    if (end === undefined) {
      end = start;
      start = 0;
    } else {
      end = toFinite(end);
    }
    number = toNumber(number);
    return baseInRange(number, start, end);
  }

  /**
   * Produces a random number between the inclusive `lower` and `upper` bounds.
   * If only one argument is provided a number between `0` and the given number
   * is returned. If `floating` is `true`, or either `lower` or `upper` are
   * floats, a floating-point number is returned instead of an integer.
   *
   * **Note:** JavaScript follows the IEEE-754 standard for resolving
   * floating-point values which can produce unexpected results.
   *
   * @static
   * @memberOf _
   * @since 0.7.0
   * @category Number
   * @param {number} [lower=0] The lower bound.
   * @param {number} [upper=1] The upper bound.
   * @param {boolean} [floating] Specify returning a floating-point number.
   * @returns {number} Returns the random number.
   * @example
   *
   * _.random(0, 5);
   * // => an integer between 0 and 5
   *
   * _.random(5);
   * // => also an integer between 0 and 5
   *
   * _.random(5, true);
   * // => a floating-point number between 0 and 5
   *
   * _.random(1.2, 5.2);
   * // => a floating-point number between 1.2 and 5.2
   */
  function random(lower, upper, floating) {
    if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {
      upper = floating = undefined;
    }
    if (floating === undefined) {
      if (typeof upper == 'boolean') {
        floating = upper;
        upper = undefined;
      }
      else if (typeof lower == 'boolean') {
        floating = lower;
        lower = undefined;
      }
    }
    if (lower === undefined && upper === undefined) {
      lower = 0;
      upper = 1;
    }
    else {
      lower = toFinite(lower);
      if (upper === undefined) {
        upper = lower;
        lower = 0;
      } else {
        upper = toFinite(upper);
      }
    }
    if (lower > upper) {
      var temp = lower;
      lower = upper;
      upper = temp;
    }
    if (floating || lower % 1 || upper % 1) {
      var rand = nativeRandom();
      return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);
    }
    return baseRandom(lower, upper);
  }

  /*------------------------------------------------------------------------*/

  /**
   * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category String
   * @param {string} [string=''] The string to convert.
   * @returns {string} Returns the camel cased string.
   * @example
   *
   * _.camelCase('Foo Bar');
   * // => 'fooBar'
   *
   * _.camelCase('--foo-bar--');
   * // => 'fooBar'
   *
   * _.camelCase('__FOO_BAR__');
   * // => 'fooBar'
   */
  var camelCase = createCompounder(function(result, word, index) {
    word = word.toLowerCase();
    return result + (index ? capitalize(word) : word);
  });

  /**
   * Converts the first character of `string` to upper case and the remaining
   * to lower case.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category String
   * @param {string} [string=''] The string to capitalize.
   * @returns {string} Returns the capitalized string.
   * @example
   *
   * _.capitalize('FRED');
   * // => 'Fred'
   */
  function capitalize(string) {
    return upperFirst(toString(string).toLowerCase());
  }

  /**
   * Deburrs `string` by converting
   * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
   * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
   * letters to basic Latin letters and removing
   * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category String
   * @param {string} [string=''] The string to deburr.
   * @returns {string} Returns the deburred string.
   * @example
   *
   * _.deburr('déjà vu');
   * // => 'deja vu'
   */
  function deburr(string) {
    string = toString(string);
    return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');
  }

  /**
   * Checks if `string` ends with the given target string.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category String
   * @param {string} [string=''] The string to inspect.
   * @param {string} [target] The string to search for.
   * @param {number} [position=string.length] The position to search up to.
   * @returns {boolean} Returns `true` if `string` ends with `target`,
   *  else `false`.
   * @example
   *
   * _.endsWith('abc', 'c');
   * // => true
   *
   * _.endsWith('abc', 'b');
   * // => false
   *
   * _.endsWith('abc', 'b', 2);
   * // => true
   */
  function endsWith(string, target, position) {
    string = toString(string);
    target = baseToString(target);

    var length = string.length;
    position = position === undefined
      ? length
      : baseClamp(toInteger(position), 0, length);

    var end = position;
    position -= target.length;
    return position >= 0 && string.slice(position, end) == target;
  }

  /**
   * Converts the characters "&", "<", ">", '"', and "'" in `string` to their
   * corresponding HTML entities.
   *
   * **Note:** No other characters are escaped. To escape additional
   * characters use a third-party library like [_he_](https://mths.be/he).
   *
   * Though the ">" character is escaped for symmetry, characters like
   * ">" and "/" don't need escaping in HTML and have no special meaning
   * unless they're part of a tag or unquoted attribute value. See
   * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)
   * (under "semi-related fun fact") for more details.
   *
   * When working with HTML you should always
   * [quote attribute values](http://wonko.com/post/html-escaping) to reduce
   * XSS vectors.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category String
   * @param {string} [string=''] The string to escape.
   * @returns {string} Returns the escaped string.
   * @example
   *
   * _.escape('fred, barney, & pebbles');
   * // => 'fred, barney, &amp; pebbles'
   */
  function escape(string) {
    string = toString(string);
    return (string && reHasUnescapedHtml.test(string))
      ? string.replace(reUnescapedHtml, escapeHtmlChar)
      : string;
  }

  /**
   * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
   * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category String
   * @param {string} [string=''] The string to escape.
   * @returns {string} Returns the escaped string.
   * @example
   *
   * _.escapeRegExp('[lodash](https://lodash.com/)');
   * // => '\[lodash\]\(https://lodash\.com/\)'
   */
  function escapeRegExp(string) {
    string = toString(string);
    return (string && reHasRegExpChar.test(string))
      ? string.replace(reRegExpChar, '\\$&')
      : string;
  }

  /**
   * Converts `string` to
   * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category String
   * @param {string} [string=''] The string to convert.
   * @returns {string} Returns the kebab cased string.
   * @example
   *
   * _.kebabCase('Foo Bar');
   * // => 'foo-bar'
   *
   * _.kebabCase('fooBar');
   * // => 'foo-bar'
   *
   * _.kebabCase('__FOO_BAR__');
   * // => 'foo-bar'
   */
  var kebabCase = createCompounder(function(result, word, index) {
    return result + (index ? '-' : '') + word.toLowerCase();
  });

  /**
   * Converts `string`, as space separated words, to lower case.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category String
   * @param {string} [string=''] The string to convert.
   * @returns {string} Returns the lower cased string.
   * @example
   *
   * _.lowerCase('--Foo-Bar--');
   * // => 'foo bar'
   *
   * _.lowerCase('fooBar');
   * // => 'foo bar'
   *
   * _.lowerCase('__FOO_BAR__');
   * // => 'foo bar'
   */
  var lowerCase = createCompounder(function(result, word, index) {
    return result + (index ? ' ' : '') + word.toLowerCase();
  });

  /**
   * Converts the first character of `string` to lower case.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category String
   * @param {string} [string=''] The string to convert.
   * @returns {string} Returns the converted string.
   * @example
   *
   * _.lowerFirst('Fred');
   * // => 'fred'
   *
   * _.lowerFirst('FRED');
   * // => 'fRED'
   */
  var lowerFirst = createCaseFirst('toLowerCase');

  /**
   * Pads `string` on the left and right sides if it's shorter than `length`.
   * Padding characters are truncated if they can't be evenly divided by `length`.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category String
   * @param {string} [string=''] The string to pad.
   * @param {number} [length=0] The padding length.
   * @param {string} [chars=' '] The string used as padding.
   * @returns {string} Returns the padded string.
   * @example
   *
   * _.pad('abc', 8);
   * // => '  abc   '
   *
   * _.pad('abc', 8, '_-');
   * // => '_-abc_-_'
   *
   * _.pad('abc', 3);
   * // => 'abc'
   */
  function pad(string, length, chars) {
    string = toString(string);
    length = toInteger(length);

    var strLength = length ? stringSize(string) : 0;
    if (!length || strLength >= length) {
      return string;
    }
    var mid = (length - strLength) / 2;
    return (
      createPadding(nativeFloor(mid), chars) +
      string +
      createPadding(nativeCeil(mid), chars)
    );
  }

  /**
   * Pads `string` on the right side if it's shorter than `length`. Padding
   * characters are truncated if they exceed `length`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category String
   * @param {string} [string=''] The string to pad.
   * @param {number} [length=0] The padding length.
   * @param {string} [chars=' '] The string used as padding.
   * @returns {string} Returns the padded string.
   * @example
   *
   * _.padEnd('abc', 6);
   * // => 'abc   '
   *
   * _.padEnd('abc', 6, '_-');
   * // => 'abc_-_'
   *
   * _.padEnd('abc', 3);
   * // => 'abc'
   */
  function padEnd(string, length, chars) {
    string = toString(string);
    length = toInteger(length);

    var strLength = length ? stringSize(string) : 0;
    return (length && strLength < length)
      ? (string + createPadding(length - strLength, chars))
      : string;
  }

  /**
   * Pads `string` on the left side if it's shorter than `length`. Padding
   * characters are truncated if they exceed `length`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category String
   * @param {string} [string=''] The string to pad.
   * @param {number} [length=0] The padding length.
   * @param {string} [chars=' '] The string used as padding.
   * @returns {string} Returns the padded string.
   * @example
   *
   * _.padStart('abc', 6);
   * // => '   abc'
   *
   * _.padStart('abc', 6, '_-');
   * // => '_-_abc'
   *
   * _.padStart('abc', 3);
   * // => 'abc'
   */
  function padStart(string, length, chars) {
    string = toString(string);
    length = toInteger(length);

    var strLength = length ? stringSize(string) : 0;
    return (length && strLength < length)
      ? (createPadding(length - strLength, chars) + string)
      : string;
  }

  /**
   * Converts `string` to an integer of the specified radix. If `radix` is
   * `undefined` or `0`, a `radix` of `10` is used unless `value` is a
   * hexadecimal, in which case a `radix` of `16` is used.
   *
   * **Note:** This method aligns with the
   * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.
   *
   * @static
   * @memberOf _
   * @since 1.1.0
   * @category String
   * @param {string} string The string to convert.
   * @param {number} [radix=10] The radix to interpret `value` by.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {number} Returns the converted integer.
   * @example
   *
   * _.parseInt('08');
   * // => 8
   *
   * _.map(['6', '08', '10'], _.parseInt);
   * // => [6, 8, 10]
   */
  function parseInt(string, radix, guard) {
    if (guard || radix == null) {
      radix = 0;
    } else if (radix) {
      radix = +radix;
    }
    return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);
  }

  /**
   * Repeats the given string `n` times.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category String
   * @param {string} [string=''] The string to repeat.
   * @param {number} [n=1] The number of times to repeat the string.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {string} Returns the repeated string.
   * @example
   *
   * _.repeat('*', 3);
   * // => '***'
   *
   * _.repeat('abc', 2);
   * // => 'abcabc'
   *
   * _.repeat('abc', 0);
   * // => ''
   */
  function repeat(string, n, guard) {
    if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {
      n = 1;
    } else {
      n = toInteger(n);
    }
    return baseRepeat(toString(string), n);
  }

  /**
   * Replaces matches for `pattern` in `string` with `replacement`.
   *
   * **Note:** This method is based on
   * [`String#replace`](https://mdn.io/String/replace).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category String
   * @param {string} [string=''] The string to modify.
   * @param {RegExp|string} pattern The pattern to replace.
   * @param {Function|string} replacement The match replacement.
   * @returns {string} Returns the modified string.
   * @example
   *
   * _.replace('Hi Fred', 'Fred', 'Barney');
   * // => 'Hi Barney'
   */
  function replace() {
    var args = arguments,
        string = toString(args[0]);

    return args.length < 3 ? string : string.replace(args[1], args[2]);
  }

  /**
   * Converts `string` to
   * [snake case](https://en.wikipedia.org/wiki/Snake_case).
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category String
   * @param {string} [string=''] The string to convert.
   * @returns {string} Returns the snake cased string.
   * @example
   *
   * _.snakeCase('Foo Bar');
   * // => 'foo_bar'
   *
   * _.snakeCase('fooBar');
   * // => 'foo_bar'
   *
   * _.snakeCase('--FOO-BAR--');
   * // => 'foo_bar'
   */
  var snakeCase = createCompounder(function(result, word, index) {
    return result + (index ? '_' : '') + word.toLowerCase();
  });

  /**
   * Splits `string` by `separator`.
   *
   * **Note:** This method is based on
   * [`String#split`](https://mdn.io/String/split).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category String
   * @param {string} [string=''] The string to split.
   * @param {RegExp|string} separator The separator pattern to split by.
   * @param {number} [limit] The length to truncate results to.
   * @returns {Array} Returns the string segments.
   * @example
   *
   * _.split('a-b-c', '-', 2);
   * // => ['a', 'b']
   */
  function split(string, separator, limit) {
    if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {
      separator = limit = undefined;
    }
    limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;
    if (!limit) {
      return [];
    }
    string = toString(string);
    if (string && (
          typeof separator == 'string' ||
          (separator != null && !isRegExp(separator))
        )) {
      separator = baseToString(separator);
      if (!separator && hasUnicode(string)) {
        return castSlice(stringToArray(string), 0, limit);
      }
    }
    return string.split(separator, limit);
  }

  /**
   * Converts `string` to
   * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).
   *
   * @static
   * @memberOf _
   * @since 3.1.0
   * @category String
   * @param {string} [string=''] The string to convert.
   * @returns {string} Returns the start cased string.
   * @example
   *
   * _.startCase('--foo-bar--');
   * // => 'Foo Bar'
   *
   * _.startCase('fooBar');
   * // => 'Foo Bar'
   *
   * _.startCase('__FOO_BAR__');
   * // => 'FOO BAR'
   */
  var startCase = createCompounder(function(result, word, index) {
    return result + (index ? ' ' : '') + upperFirst(word);
  });

  /**
   * Checks if `string` starts with the given target string.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category String
   * @param {string} [string=''] The string to inspect.
   * @param {string} [target] The string to search for.
   * @param {number} [position=0] The position to search from.
   * @returns {boolean} Returns `true` if `string` starts with `target`,
   *  else `false`.
   * @example
   *
   * _.startsWith('abc', 'a');
   * // => true
   *
   * _.startsWith('abc', 'b');
   * // => false
   *
   * _.startsWith('abc', 'b', 1);
   * // => true
   */
  function startsWith(string, target, position) {
    string = toString(string);
    position = position == null
      ? 0
      : baseClamp(toInteger(position), 0, string.length);

    target = baseToString(target);
    return string.slice(position, position + target.length) == target;
  }

  /**
   * Creates a compiled template function that can interpolate data properties
   * in "interpolate" delimiters, HTML-escape interpolated data properties in
   * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data
   * properties may be accessed as free variables in the template. If a setting
   * object is given, it takes precedence over `_.templateSettings` values.
   *
   * **Note:** In the development build `_.template` utilizes
   * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)
   * for easier debugging.
   *
   * For more information on precompiling templates see
   * [lodash's custom builds documentation](https://lodash.com/custom-builds).
   *
   * For more information on Chrome extension sandboxes see
   * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category String
   * @param {string} [string=''] The template string.
   * @param {Object} [options={}] The options object.
   * @param {RegExp} [options.escape=_.templateSettings.escape]
   *  The HTML "escape" delimiter.
   * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]
   *  The "evaluate" delimiter.
   * @param {Object} [options.imports=_.templateSettings.imports]
   *  An object to import into the template as free variables.
   * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]
   *  The "interpolate" delimiter.
   * @param {string} [options.sourceURL='lodash.templateSources[n]']
   *  The sourceURL of the compiled template.
   * @param {string} [options.variable='obj']
   *  The data object variable name.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {Function} Returns the compiled template function.
   * @example
   *
   * // Use the "interpolate" delimiter to create a compiled template.
   * var compiled = _.template('hello <%= user %>!');
   * compiled({ 'user': 'fred' });
   * // => 'hello fred!'
   *
   * // Use the HTML "escape" delimiter to escape data property values.
   * var compiled = _.template('<b><%- value %></b>');
   * compiled({ 'value': '<script>' });
   * // => '<b>&lt;script&gt;</b>'
   *
   * // Use the "evaluate" delimiter to execute JavaScript and generate HTML.
   * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');
   * compiled({ 'users': ['fred', 'barney'] });
   * // => '<li>fred</li><li>barney</li>'
   *
   * // Use the internal `print` function in "evaluate" delimiters.
   * var compiled = _.template('<% print("hello " + user); %>!');
   * compiled({ 'user': 'barney' });
   * // => 'hello barney!'
   *
   * // Use the ES template literal delimiter as an "interpolate" delimiter.
   * // Disable support by replacing the "interpolate" delimiter.
   * var compiled = _.template('hello ${ user }!');
   * compiled({ 'user': 'pebbles' });
   * // => 'hello pebbles!'
   *
   * // Use backslashes to treat delimiters as plain text.
   * var compiled = _.template('<%= "\\<%- value %\\>" %>');
   * compiled({ 'value': 'ignored' });
   * // => '<%- value %>'
   *
   * // Use the `imports` option to import `jQuery` as `jq`.
   * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';
   * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });
   * compiled({ 'users': ['fred', 'barney'] });
   * // => '<li>fred</li><li>barney</li>'
   *
   * // Use the `sourceURL` option to specify a custom sourceURL for the template.
   * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });
   * compiled(data);
   * // => Find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector.
   *
   * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.
   * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });
   * compiled.source;
   * // => function(data) {
   * //   var __t, __p = '';
   * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';
   * //   return __p;
   * // }
   *
   * // Use custom template delimiters.
   * _.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
   * var compiled = _.template('hello {{ user }}!');
   * compiled({ 'user': 'mustache' });
   * // => 'hello mustache!'
   *
   * // Use the `source` property to inline compiled templates for meaningful
   * // line numbers in error messages and stack traces.
   * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\
   *   var JST = {\
   *     "main": ' + _.template(mainText).source + '\
   *   };\
   * ');
   */
  function template(string, options, guard) {
    // Based on John Resig's `tmpl` implementation
    // (http://ejohn.org/blog/javascript-micro-templating/)
    // and Laura Doktorova's doT.js (https://github.com/olado/doT).
    var settings = lodash.templateSettings;

    if (guard && isIterateeCall(string, options, guard)) {
      options = undefined;
    }
    string = toString(string);
    options = assignInWith({}, options, settings, customDefaultsAssignIn);

    var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),
        importsKeys = keys(imports),
        importsValues = baseValues(imports, importsKeys);

    var isEscaping,
        isEvaluating,
        index = 0,
        interpolate = options.interpolate || reNoMatch,
        source = "__p += '";

    // Compile the regexp to match each delimiter.
    var reDelimiters = RegExp(
      (options.escape || reNoMatch).source + '|' +
      interpolate.source + '|' +
      (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
      (options.evaluate || reNoMatch).source + '|$'
    , 'g');

    // Use a sourceURL for easier debugging.
    var sourceURL = '//# sourceURL=' +
      ('sourceURL' in options
        ? options.sourceURL
        : ('lodash.templateSources[' + (++templateCounter) + ']')
      ) + '\n';

    string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
      interpolateValue || (interpolateValue = esTemplateValue);

      // Escape characters that can't be included in string literals.
      source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);

      // Replace delimiters with snippets.
      if (escapeValue) {
        isEscaping = true;
        source += "' +\n__e(" + escapeValue + ") +\n'";
      }
      if (evaluateValue) {
        isEvaluating = true;
        source += "';\n" + evaluateValue + ";\n__p += '";
      }
      if (interpolateValue) {
        source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
      }
      index = offset + match.length;

      // The JS engine embedded in Adobe products needs `match` returned in
      // order to produce the correct `offset` value.
      return match;
    });

    source += "';\n";

    // If `variable` is not specified wrap a with-statement around the generated
    // code to add the data object to the top of the scope chain.
    var variable = options.variable;
    if (!variable) {
      source = 'with (obj) {\n' + source + '\n}\n';
    }
    // Cleanup code by stripping empty strings.
    source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
      .replace(reEmptyStringMiddle, '$1')
      .replace(reEmptyStringTrailing, '$1;');

    // Frame code as the function body.
    source = 'function(' + (variable || 'obj') + ') {\n' +
      (variable
        ? ''
        : 'obj || (obj = {});\n'
      ) +
      "var __t, __p = ''" +
      (isEscaping
         ? ', __e = _.escape'
         : ''
      ) +
      (isEvaluating
        ? ', __j = Array.prototype.join;\n' +
          "function print() { __p += __j.call(arguments, '') }\n"
        : ';\n'
      ) +
      source +
      'return __p\n}';

    var result = attempt(function() {
      return Function(importsKeys, sourceURL + 'return ' + source)
        .apply(undefined, importsValues);
    });

    // Provide the compiled function's source by its `toString` method or
    // the `source` property as a convenience for inlining compiled templates.
    result.source = source;
    if (isError(result)) {
      throw result;
    }
    return result;
  }

  /**
   * Converts `string`, as a whole, to lower case just like
   * [String#toLowerCase](https://mdn.io/toLowerCase).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category String
   * @param {string} [string=''] The string to convert.
   * @returns {string} Returns the lower cased string.
   * @example
   *
   * _.toLower('--Foo-Bar--');
   * // => '--foo-bar--'
   *
   * _.toLower('fooBar');
   * // => 'foobar'
   *
   * _.toLower('__FOO_BAR__');
   * // => '__foo_bar__'
   */
  function toLower(value) {
    return toString(value).toLowerCase();
  }

  /**
   * Converts `string`, as a whole, to upper case just like
   * [String#toUpperCase](https://mdn.io/toUpperCase).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category String
   * @param {string} [string=''] The string to convert.
   * @returns {string} Returns the upper cased string.
   * @example
   *
   * _.toUpper('--foo-bar--');
   * // => '--FOO-BAR--'
   *
   * _.toUpper('fooBar');
   * // => 'FOOBAR'
   *
   * _.toUpper('__foo_bar__');
   * // => '__FOO_BAR__'
   */
  function toUpper(value) {
    return toString(value).toUpperCase();
  }

  /**
   * Removes leading and trailing whitespace or specified characters from `string`.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category String
   * @param {string} [string=''] The string to trim.
   * @param {string} [chars=whitespace] The characters to trim.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {string} Returns the trimmed string.
   * @example
   *
   * _.trim('  abc  ');
   * // => 'abc'
   *
   * _.trim('-_-abc-_-', '_-');
   * // => 'abc'
   *
   * _.map(['  foo  ', '  bar  '], _.trim);
   * // => ['foo', 'bar']
   */
  function trim(string, chars, guard) {
    string = toString(string);
    if (string && (guard || chars === undefined)) {
      return string.replace(reTrim, '');
    }
    if (!string || !(chars = baseToString(chars))) {
      return string;
    }
    var strSymbols = stringToArray(string),
        chrSymbols = stringToArray(chars),
        start = charsStartIndex(strSymbols, chrSymbols),
        end = charsEndIndex(strSymbols, chrSymbols) + 1;

    return castSlice(strSymbols, start, end).join('');
  }

  /**
   * Removes trailing whitespace or specified characters from `string`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category String
   * @param {string} [string=''] The string to trim.
   * @param {string} [chars=whitespace] The characters to trim.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {string} Returns the trimmed string.
   * @example
   *
   * _.trimEnd('  abc  ');
   * // => '  abc'
   *
   * _.trimEnd('-_-abc-_-', '_-');
   * // => '-_-abc'
   */
  function trimEnd(string, chars, guard) {
    string = toString(string);
    if (string && (guard || chars === undefined)) {
      return string.replace(reTrimEnd, '');
    }
    if (!string || !(chars = baseToString(chars))) {
      return string;
    }
    var strSymbols = stringToArray(string),
        end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;

    return castSlice(strSymbols, 0, end).join('');
  }

  /**
   * Removes leading whitespace or specified characters from `string`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category String
   * @param {string} [string=''] The string to trim.
   * @param {string} [chars=whitespace] The characters to trim.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {string} Returns the trimmed string.
   * @example
   *
   * _.trimStart('  abc  ');
   * // => 'abc  '
   *
   * _.trimStart('-_-abc-_-', '_-');
   * // => 'abc-_-'
   */
  function trimStart(string, chars, guard) {
    string = toString(string);
    if (string && (guard || chars === undefined)) {
      return string.replace(reTrimStart, '');
    }
    if (!string || !(chars = baseToString(chars))) {
      return string;
    }
    var strSymbols = stringToArray(string),
        start = charsStartIndex(strSymbols, stringToArray(chars));

    return castSlice(strSymbols, start).join('');
  }

  /**
   * Truncates `string` if it's longer than the given maximum string length.
   * The last characters of the truncated string are replaced with the omission
   * string which defaults to "...".
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category String
   * @param {string} [string=''] The string to truncate.
   * @param {Object} [options={}] The options object.
   * @param {number} [options.length=30] The maximum string length.
   * @param {string} [options.omission='...'] The string to indicate text is omitted.
   * @param {RegExp|string} [options.separator] The separator pattern to truncate to.
   * @returns {string} Returns the truncated string.
   * @example
   *
   * _.truncate('hi-diddly-ho there, neighborino');
   * // => 'hi-diddly-ho there, neighbo...'
   *
   * _.truncate('hi-diddly-ho there, neighborino', {
   *   'length': 24,
   *   'separator': ' '
   * });
   * // => 'hi-diddly-ho there,...'
   *
   * _.truncate('hi-diddly-ho there, neighborino', {
   *   'length': 24,
   *   'separator': /,? +/
   * });
   * // => 'hi-diddly-ho there...'
   *
   * _.truncate('hi-diddly-ho there, neighborino', {
   *   'omission': ' [...]'
   * });
   * // => 'hi-diddly-ho there, neig [...]'
   */
  function truncate(string, options) {
    var length = DEFAULT_TRUNC_LENGTH,
        omission = DEFAULT_TRUNC_OMISSION;

    if (isObject(options)) {
      var separator = 'separator' in options ? options.separator : separator;
      length = 'length' in options ? toInteger(options.length) : length;
      omission = 'omission' in options ? baseToString(options.omission) : omission;
    }
    string = toString(string);

    var strLength = string.length;
    if (hasUnicode(string)) {
      var strSymbols = stringToArray(string);
      strLength = strSymbols.length;
    }
    if (length >= strLength) {
      return string;
    }
    var end = length - stringSize(omission);
    if (end < 1) {
      return omission;
    }
    var result = strSymbols
      ? castSlice(strSymbols, 0, end).join('')
      : string.slice(0, end);

    if (separator === undefined) {
      return result + omission;
    }
    if (strSymbols) {
      end += (result.length - end);
    }
    if (isRegExp(separator)) {
      if (string.slice(end).search(separator)) {
        var match,
            substring = result;

        if (!separator.global) {
          separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');
        }
        separator.lastIndex = 0;
        while ((match = separator.exec(substring))) {
          var newEnd = match.index;
        }
        result = result.slice(0, newEnd === undefined ? end : newEnd);
      }
    } else if (string.indexOf(baseToString(separator), end) != end) {
      var index = result.lastIndexOf(separator);
      if (index > -1) {
        result = result.slice(0, index);
      }
    }
    return result + omission;
  }

  /**
   * The inverse of `_.escape`; this method converts the HTML entities
   * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to
   * their corresponding characters.
   *
   * **Note:** No other HTML entities are unescaped. To unescape additional
   * HTML entities use a third-party library like [_he_](https://mths.be/he).
   *
   * @static
   * @memberOf _
   * @since 0.6.0
   * @category String
   * @param {string} [string=''] The string to unescape.
   * @returns {string} Returns the unescaped string.
   * @example
   *
   * _.unescape('fred, barney, &amp; pebbles');
   * // => 'fred, barney, & pebbles'
   */
  function unescape(string) {
    string = toString(string);
    return (string && reHasEscapedHtml.test(string))
      ? string.replace(reEscapedHtml, unescapeHtmlChar)
      : string;
  }

  /**
   * Converts `string`, as space separated words, to upper case.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category String
   * @param {string} [string=''] The string to convert.
   * @returns {string} Returns the upper cased string.
   * @example
   *
   * _.upperCase('--foo-bar');
   * // => 'FOO BAR'
   *
   * _.upperCase('fooBar');
   * // => 'FOO BAR'
   *
   * _.upperCase('__foo_bar__');
   * // => 'FOO BAR'
   */
  var upperCase = createCompounder(function(result, word, index) {
    return result + (index ? ' ' : '') + word.toUpperCase();
  });

  /**
   * Converts the first character of `string` to upper case.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category String
   * @param {string} [string=''] The string to convert.
   * @returns {string} Returns the converted string.
   * @example
   *
   * _.upperFirst('fred');
   * // => 'Fred'
   *
   * _.upperFirst('FRED');
   * // => 'FRED'
   */
  var upperFirst = createCaseFirst('toUpperCase');

  /**
   * Splits `string` into an array of its words.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category String
   * @param {string} [string=''] The string to inspect.
   * @param {RegExp|string} [pattern] The pattern to match words.
   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
   * @returns {Array} Returns the words of `string`.
   * @example
   *
   * _.words('fred, barney, & pebbles');
   * // => ['fred', 'barney', 'pebbles']
   *
   * _.words('fred, barney, & pebbles', /[^, ]+/g);
   * // => ['fred', 'barney', '&', 'pebbles']
   */
  function words(string, pattern, guard) {
    string = toString(string);
    pattern = guard ? undefined : pattern;

    if (pattern === undefined) {
      return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
    }
    return string.match(pattern) || [];
  }

  /*------------------------------------------------------------------------*/

  /**
   * Attempts to invoke `func`, returning either the result or the caught error
   * object. Any additional arguments are provided to `func` when it's invoked.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Util
   * @param {Function} func The function to attempt.
   * @param {...*} [args] The arguments to invoke `func` with.
   * @returns {*} Returns the `func` result or error object.
   * @example
   *
   * // Avoid throwing errors for invalid selectors.
   * var elements = _.attempt(function(selector) {
   *   return document.querySelectorAll(selector);
   * }, '>_>');
   *
   * if (_.isError(elements)) {
   *   elements = [];
   * }
   */
  var attempt = baseRest(function(func, args) {
    try {
      return apply(func, undefined, args);
    } catch (e) {
      return isError(e) ? e : new Error(e);
    }
  });

  /**
   * Binds methods of an object to the object itself, overwriting the existing
   * method.
   *
   * **Note:** This method doesn't set the "length" property of bound functions.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Util
   * @param {Object} object The object to bind and assign the bound methods to.
   * @param {...(string|string[])} methodNames The object method names to bind.
   * @returns {Object} Returns `object`.
   * @example
   *
   * var view = {
   *   'label': 'docs',
   *   'click': function() {
   *     console.log('clicked ' + this.label);
   *   }
   * };
   *
   * _.bindAll(view, ['click']);
   * jQuery(element).on('click', view.click);
   * // => Logs 'clicked docs' when clicked.
   */
  var bindAll = flatRest(function(object, methodNames) {
    arrayEach(methodNames, function(key) {
      key = toKey(key);
      baseAssignValue(object, key, bind(object[key], object));
    });
    return object;
  });

  /**
   * Creates a function that iterates over `pairs` and invokes the corresponding
   * function of the first predicate to return truthy. The predicate-function
   * pairs are invoked with the `this` binding and arguments of the created
   * function.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Util
   * @param {Array} pairs The predicate-function pairs.
   * @returns {Function} Returns the new composite function.
   * @example
   *
   * var func = _.cond([
   *   [_.matches({ 'a': 1 }),           _.constant('matches A')],
   *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],
   *   [_.stubTrue,                      _.constant('no match')]
   * ]);
   *
   * func({ 'a': 1, 'b': 2 });
   * // => 'matches A'
   *
   * func({ 'a': 0, 'b': 1 });
   * // => 'matches B'
   *
   * func({ 'a': '1', 'b': '2' });
   * // => 'no match'
   */
  function cond(pairs) {
    var length = pairs == null ? 0 : pairs.length,
        toIteratee = getIteratee();

    pairs = !length ? [] : arrayMap(pairs, function(pair) {
      if (typeof pair[1] != 'function') {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      return [toIteratee(pair[0]), pair[1]];
    });

    return baseRest(function(args) {
      var index = -1;
      while (++index < length) {
        var pair = pairs[index];
        if (apply(pair[0], this, args)) {
          return apply(pair[1], this, args);
        }
      }
    });
  }

  /**
   * Creates a function that invokes the predicate properties of `source` with
   * the corresponding property values of a given object, returning `true` if
   * all predicates return truthy, else `false`.
   *
   * **Note:** The created function is equivalent to `_.conformsTo` with
   * `source` partially applied.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Util
   * @param {Object} source The object of property predicates to conform to.
   * @returns {Function} Returns the new spec function.
   * @example
   *
   * var objects = [
   *   { 'a': 2, 'b': 1 },
   *   { 'a': 1, 'b': 2 }
   * ];
   *
   * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));
   * // => [{ 'a': 1, 'b': 2 }]
   */
  function conforms(source) {
    return baseConforms(baseClone(source, CLONE_DEEP_FLAG));
  }

  /**
   * Creates a function that returns `value`.
   *
   * @static
   * @memberOf _
   * @since 2.4.0
   * @category Util
   * @param {*} value The value to return from the new function.
   * @returns {Function} Returns the new constant function.
   * @example
   *
   * var objects = _.times(2, _.constant({ 'a': 1 }));
   *
   * console.log(objects);
   * // => [{ 'a': 1 }, { 'a': 1 }]
   *
   * console.log(objects[0] === objects[1]);
   * // => true
   */
  function constant(value) {
    return function() {
      return value;
    };
  }

  /**
   * Checks `value` to determine whether a default value should be returned in
   * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,
   * or `undefined`.
   *
   * @static
   * @memberOf _
   * @since 4.14.0
   * @category Util
   * @param {*} value The value to check.
   * @param {*} defaultValue The default value.
   * @returns {*} Returns the resolved value.
   * @example
   *
   * _.defaultTo(1, 10);
   * // => 1
   *
   * _.defaultTo(undefined, 10);
   * // => 10
   */
  function defaultTo(value, defaultValue) {
    return (value == null || value !== value) ? defaultValue : value;
  }

  /**
   * Creates a function that returns the result of invoking the given functions
   * with the `this` binding of the created function, where each successive
   * invocation is supplied the return value of the previous.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Util
   * @param {...(Function|Function[])} [funcs] The functions to invoke.
   * @returns {Function} Returns the new composite function.
   * @see _.flowRight
   * @example
   *
   * function square(n) {
   *   return n * n;
   * }
   *
   * var addSquare = _.flow([_.add, square]);
   * addSquare(1, 2);
   * // => 9
   */
  var flow = createFlow();

  /**
   * This method is like `_.flow` except that it creates a function that
   * invokes the given functions from right to left.
   *
   * @static
   * @since 3.0.0
   * @memberOf _
   * @category Util
   * @param {...(Function|Function[])} [funcs] The functions to invoke.
   * @returns {Function} Returns the new composite function.
   * @see _.flow
   * @example
   *
   * function square(n) {
   *   return n * n;
   * }
   *
   * var addSquare = _.flowRight([square, _.add]);
   * addSquare(1, 2);
   * // => 9
   */
  var flowRight = createFlow(true);

  /**
   * This method returns the first argument it receives.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Util
   * @param {*} value Any value.
   * @returns {*} Returns `value`.
   * @example
   *
   * var object = { 'a': 1 };
   *
   * console.log(_.identity(object) === object);
   * // => true
   */
  function identity(value) {
    return value;
  }

  /**
   * Creates a function that invokes `func` with the arguments of the created
   * function. If `func` is a property name, the created function returns the
   * property value for a given element. If `func` is an array or object, the
   * created function returns `true` for elements that contain the equivalent
   * source properties, otherwise it returns `false`.
   *
   * @static
   * @since 4.0.0
   * @memberOf _
   * @category Util
   * @param {*} [func=_.identity] The value to convert to a callback.
   * @returns {Function} Returns the callback.
   * @example
   *
   * var users = [
   *   { 'user': 'barney', 'age': 36, 'active': true },
   *   { 'user': 'fred',   'age': 40, 'active': false }
   * ];
   *
   * // The `_.matches` iteratee shorthand.
   * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
   * // => [{ 'user': 'barney', 'age': 36, 'active': true }]
   *
   * // The `_.matchesProperty` iteratee shorthand.
   * _.filter(users, _.iteratee(['user', 'fred']));
   * // => [{ 'user': 'fred', 'age': 40 }]
   *
   * // The `_.property` iteratee shorthand.
   * _.map(users, _.iteratee('user'));
   * // => ['barney', 'fred']
   *
   * // Create custom iteratee shorthands.
   * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
   *   return !_.isRegExp(func) ? iteratee(func) : function(string) {
   *     return func.test(string);
   *   };
   * });
   *
   * _.filter(['abc', 'def'], /ef/);
   * // => ['def']
   */
  function iteratee(func) {
    return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));
  }

  /**
   * Creates a function that performs a partial deep comparison between a given
   * object and `source`, returning `true` if the given object has equivalent
   * property values, else `false`.
   *
   * **Note:** The created function is equivalent to `_.isMatch` with `source`
   * partially applied.
   *
   * Partial comparisons will match empty array and empty object `source`
   * values against any array or object value, respectively. See `_.isEqual`
   * for a list of supported value comparisons.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Util
   * @param {Object} source The object of property values to match.
   * @returns {Function} Returns the new spec function.
   * @example
   *
   * var objects = [
   *   { 'a': 1, 'b': 2, 'c': 3 },
   *   { 'a': 4, 'b': 5, 'c': 6 }
   * ];
   *
   * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));
   * // => [{ 'a': 4, 'b': 5, 'c': 6 }]
   */
  function matches(source) {
    return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
  }

  /**
   * Creates a function that performs a partial deep comparison between the
   * value at `path` of a given object to `srcValue`, returning `true` if the
   * object value is equivalent, else `false`.
   *
   * **Note:** Partial comparisons will match empty array and empty object
   * `srcValue` values against any array or object value, respectively. See
   * `_.isEqual` for a list of supported value comparisons.
   *
   * @static
   * @memberOf _
   * @since 3.2.0
   * @category Util
   * @param {Array|string} path The path of the property to get.
   * @param {*} srcValue The value to match.
   * @returns {Function} Returns the new spec function.
   * @example
   *
   * var objects = [
   *   { 'a': 1, 'b': 2, 'c': 3 },
   *   { 'a': 4, 'b': 5, 'c': 6 }
   * ];
   *
   * _.find(objects, _.matchesProperty('a', 4));
   * // => { 'a': 4, 'b': 5, 'c': 6 }
   */
  function matchesProperty(path, srcValue) {
    return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));
  }

  /**
   * Creates a function that invokes the method at `path` of a given object.
   * Any additional arguments are provided to the invoked method.
   *
   * @static
   * @memberOf _
   * @since 3.7.0
   * @category Util
   * @param {Array|string} path The path of the method to invoke.
   * @param {...*} [args] The arguments to invoke the method with.
   * @returns {Function} Returns the new invoker function.
   * @example
   *
   * var objects = [
   *   { 'a': { 'b': _.constant(2) } },
   *   { 'a': { 'b': _.constant(1) } }
   * ];
   *
   * _.map(objects, _.method('a.b'));
   * // => [2, 1]
   *
   * _.map(objects, _.method(['a', 'b']));
   * // => [2, 1]
   */
  var method = baseRest(function(path, args) {
    return function(object) {
      return baseInvoke(object, path, args);
    };
  });

  /**
   * The opposite of `_.method`; this method creates a function that invokes
   * the method at a given path of `object`. Any additional arguments are
   * provided to the invoked method.
   *
   * @static
   * @memberOf _
   * @since 3.7.0
   * @category Util
   * @param {Object} object The object to query.
   * @param {...*} [args] The arguments to invoke the method with.
   * @returns {Function} Returns the new invoker function.
   * @example
   *
   * var array = _.times(3, _.constant),
   *     object = { 'a': array, 'b': array, 'c': array };
   *
   * _.map(['a[2]', 'c[0]'], _.methodOf(object));
   * // => [2, 0]
   *
   * _.map([['a', '2'], ['c', '0']], _.methodOf(object));
   * // => [2, 0]
   */
  var methodOf = baseRest(function(object, args) {
    return function(path) {
      return baseInvoke(object, path, args);
    };
  });

  /**
   * Adds all own enumerable string keyed function properties of a source
   * object to the destination object. If `object` is a function, then methods
   * are added to its prototype as well.
   *
   * **Note:** Use `_.runInContext` to create a pristine `lodash` function to
   * avoid conflicts caused by modifying the original.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Util
   * @param {Function|Object} [object=lodash] The destination object.
   * @param {Object} source The object of functions to add.
   * @param {Object} [options={}] The options object.
   * @param {boolean} [options.chain=true] Specify whether mixins are chainable.
   * @returns {Function|Object} Returns `object`.
   * @example
   *
   * function vowels(string) {
   *   return _.filter(string, function(v) {
   *     return /[aeiou]/i.test(v);
   *   });
   * }
   *
   * _.mixin({ 'vowels': vowels });
   * _.vowels('fred');
   * // => ['e']
   *
   * _('fred').vowels().value();
   * // => ['e']
   *
   * _.mixin({ 'vowels': vowels }, { 'chain': false });
   * _('fred').vowels();
   * // => ['e']
   */
  function mixin(object, source, options) {
    var props = keys(source),
        methodNames = baseFunctions(source, props);

    if (options == null &&
        !(isObject(source) && (methodNames.length || !props.length))) {
      options = source;
      source = object;
      object = this;
      methodNames = baseFunctions(source, keys(source));
    }
    var chain = !(isObject(options) && 'chain' in options) || !!options.chain,
        isFunc = isFunction(object);

    arrayEach(methodNames, function(methodName) {
      var func = source[methodName];
      object[methodName] = func;
      if (isFunc) {
        object.prototype[methodName] = function() {
          var chainAll = this.__chain__;
          if (chain || chainAll) {
            var result = object(this.__wrapped__),
                actions = result.__actions__ = copyArray(this.__actions__);

            actions.push({ 'func': func, 'args': arguments, 'thisArg': object });
            result.__chain__ = chainAll;
            return result;
          }
          return func.apply(object, arrayPush([this.value()], arguments));
        };
      }
    });

    return object;
  }

  /**
   * Reverts the `_` variable to its previous value and returns a reference to
   * the `lodash` function.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Util
   * @returns {Function} Returns the `lodash` function.
   * @example
   *
   * var lodash = _.noConflict();
   */
  function noConflict() {
    if (root._ === this) {
      root._ = oldDash;
    }
    return this;
  }

  /**
   * This method returns `undefined`.
   *
   * @static
   * @memberOf _
   * @since 2.3.0
   * @category Util
   * @example
   *
   * _.times(2, _.noop);
   * // => [undefined, undefined]
   */
  function noop() {
    // No operation performed.
  }

  /**
   * Creates a function that gets the argument at index `n`. If `n` is negative,
   * the nth argument from the end is returned.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Util
   * @param {number} [n=0] The index of the argument to return.
   * @returns {Function} Returns the new pass-thru function.
   * @example
   *
   * var func = _.nthArg(1);
   * func('a', 'b', 'c', 'd');
   * // => 'b'
   *
   * var func = _.nthArg(-2);
   * func('a', 'b', 'c', 'd');
   * // => 'c'
   */
  function nthArg(n) {
    n = toInteger(n);
    return baseRest(function(args) {
      return baseNth(args, n);
    });
  }

  /**
   * Creates a function that invokes `iteratees` with the arguments it receives
   * and returns their results.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Util
   * @param {...(Function|Function[])} [iteratees=[_.identity]]
   *  The iteratees to invoke.
   * @returns {Function} Returns the new function.
   * @example
   *
   * var func = _.over([Math.max, Math.min]);
   *
   * func(1, 2, 3, 4);
   * // => [4, 1]
   */
  var over = createOver(arrayMap);

  /**
   * Creates a function that checks if **all** of the `predicates` return
   * truthy when invoked with the arguments it receives.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Util
   * @param {...(Function|Function[])} [predicates=[_.identity]]
   *  The predicates to check.
   * @returns {Function} Returns the new function.
   * @example
   *
   * var func = _.overEvery([Boolean, isFinite]);
   *
   * func('1');
   * // => true
   *
   * func(null);
   * // => false
   *
   * func(NaN);
   * // => false
   */
  var overEvery = createOver(arrayEvery);

  /**
   * Creates a function that checks if **any** of the `predicates` return
   * truthy when invoked with the arguments it receives.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Util
   * @param {...(Function|Function[])} [predicates=[_.identity]]
   *  The predicates to check.
   * @returns {Function} Returns the new function.
   * @example
   *
   * var func = _.overSome([Boolean, isFinite]);
   *
   * func('1');
   * // => true
   *
   * func(null);
   * // => true
   *
   * func(NaN);
   * // => false
   */
  var overSome = createOver(arraySome);

  /**
   * Creates a function that returns the value at `path` of a given object.
   *
   * @static
   * @memberOf _
   * @since 2.4.0
   * @category Util
   * @param {Array|string} path The path of the property to get.
   * @returns {Function} Returns the new accessor function.
   * @example
   *
   * var objects = [
   *   { 'a': { 'b': 2 } },
   *   { 'a': { 'b': 1 } }
   * ];
   *
   * _.map(objects, _.property('a.b'));
   * // => [2, 1]
   *
   * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
   * // => [1, 2]
   */
  function property(path) {
    return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
  }

  /**
   * The opposite of `_.property`; this method creates a function that returns
   * the value at a given path of `object`.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Util
   * @param {Object} object The object to query.
   * @returns {Function} Returns the new accessor function.
   * @example
   *
   * var array = [0, 1, 2],
   *     object = { 'a': array, 'b': array, 'c': array };
   *
   * _.map(['a[2]', 'c[0]'], _.propertyOf(object));
   * // => [2, 0]
   *
   * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));
   * // => [2, 0]
   */
  function propertyOf(object) {
    return function(path) {
      return object == null ? undefined : baseGet(object, path);
    };
  }

  /**
   * Creates an array of numbers (positive and/or negative) progressing from
   * `start` up to, but not including, `end`. A step of `-1` is used if a negative
   * `start` is specified without an `end` or `step`. If `end` is not specified,
   * it's set to `start` with `start` then set to `0`.
   *
   * **Note:** JavaScript follows the IEEE-754 standard for resolving
   * floating-point values which can produce unexpected results.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Util
   * @param {number} [start=0] The start of the range.
   * @param {number} end The end of the range.
   * @param {number} [step=1] The value to increment or decrement by.
   * @returns {Array} Returns the range of numbers.
   * @see _.inRange, _.rangeRight
   * @example
   *
   * _.range(4);
   * // => [0, 1, 2, 3]
   *
   * _.range(-4);
   * // => [0, -1, -2, -3]
   *
   * _.range(1, 5);
   * // => [1, 2, 3, 4]
   *
   * _.range(0, 20, 5);
   * // => [0, 5, 10, 15]
   *
   * _.range(0, -4, -1);
   * // => [0, -1, -2, -3]
   *
   * _.range(1, 4, 0);
   * // => [1, 1, 1]
   *
   * _.range(0);
   * // => []
   */
  var range = createRange();

  /**
   * This method is like `_.range` except that it populates values in
   * descending order.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Util
   * @param {number} [start=0] The start of the range.
   * @param {number} end The end of the range.
   * @param {number} [step=1] The value to increment or decrement by.
   * @returns {Array} Returns the range of numbers.
   * @see _.inRange, _.range
   * @example
   *
   * _.rangeRight(4);
   * // => [3, 2, 1, 0]
   *
   * _.rangeRight(-4);
   * // => [-3, -2, -1, 0]
   *
   * _.rangeRight(1, 5);
   * // => [4, 3, 2, 1]
   *
   * _.rangeRight(0, 20, 5);
   * // => [15, 10, 5, 0]
   *
   * _.rangeRight(0, -4, -1);
   * // => [-3, -2, -1, 0]
   *
   * _.rangeRight(1, 4, 0);
   * // => [1, 1, 1]
   *
   * _.rangeRight(0);
   * // => []
   */
  var rangeRight = createRange(true);

  /**
   * This method returns a new empty array.
   *
   * @static
   * @memberOf _
   * @since 4.13.0
   * @category Util
   * @returns {Array} Returns the new empty array.
   * @example
   *
   * var arrays = _.times(2, _.stubArray);
   *
   * console.log(arrays);
   * // => [[], []]
   *
   * console.log(arrays[0] === arrays[1]);
   * // => false
   */
  function stubArray() {
    return [];
  }

  /**
   * This method returns `false`.
   *
   * @static
   * @memberOf _
   * @since 4.13.0
   * @category Util
   * @returns {boolean} Returns `false`.
   * @example
   *
   * _.times(2, _.stubFalse);
   * // => [false, false]
   */
  function stubFalse() {
    return false;
  }

  /**
   * This method returns a new empty object.
   *
   * @static
   * @memberOf _
   * @since 4.13.0
   * @category Util
   * @returns {Object} Returns the new empty object.
   * @example
   *
   * var objects = _.times(2, _.stubObject);
   *
   * console.log(objects);
   * // => [{}, {}]
   *
   * console.log(objects[0] === objects[1]);
   * // => false
   */
  function stubObject() {
    return {};
  }

  /**
   * This method returns an empty string.
   *
   * @static
   * @memberOf _
   * @since 4.13.0
   * @category Util
   * @returns {string} Returns the empty string.
   * @example
   *
   * _.times(2, _.stubString);
   * // => ['', '']
   */
  function stubString() {
    return '';
  }

  /**
   * This method returns `true`.
   *
   * @static
   * @memberOf _
   * @since 4.13.0
   * @category Util
   * @returns {boolean} Returns `true`.
   * @example
   *
   * _.times(2, _.stubTrue);
   * // => [true, true]
   */
  function stubTrue() {
    return true;
  }

  /**
   * Invokes the iteratee `n` times, returning an array of the results of
   * each invocation. The iteratee is invoked with one argument; (index).
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Util
   * @param {number} n The number of times to invoke `iteratee`.
   * @param {Function} [iteratee=_.identity] The function invoked per iteration.
   * @returns {Array} Returns the array of results.
   * @example
   *
   * _.times(3, String);
   * // => ['0', '1', '2']
   *
   *  _.times(4, _.constant(0));
   * // => [0, 0, 0, 0]
   */
  function times(n, iteratee) {
    n = toInteger(n);
    if (n < 1 || n > MAX_SAFE_INTEGER) {
      return [];
    }
    var index = MAX_ARRAY_LENGTH,
        length = nativeMin(n, MAX_ARRAY_LENGTH);

    iteratee = getIteratee(iteratee);
    n -= MAX_ARRAY_LENGTH;

    var result = baseTimes(length, iteratee);
    while (++index < n) {
      iteratee(index);
    }
    return result;
  }

  /**
   * Converts `value` to a property path array.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Util
   * @param {*} value The value to convert.
   * @returns {Array} Returns the new property path array.
   * @example
   *
   * _.toPath('a.b.c');
   * // => ['a', 'b', 'c']
   *
   * _.toPath('a[0].b.c');
   * // => ['a', '0', 'b', 'c']
   */
  function toPath(value) {
    if (isArray(value)) {
      return arrayMap(value, toKey);
    }
    return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));
  }

  /**
   * Generates a unique ID. If `prefix` is given, the ID is appended to it.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Util
   * @param {string} [prefix=''] The value to prefix the ID with.
   * @returns {string} Returns the unique ID.
   * @example
   *
   * _.uniqueId('contact_');
   * // => 'contact_104'
   *
   * _.uniqueId();
   * // => '105'
   */
  function uniqueId(prefix) {
    var id = ++idCounter;
    return toString(prefix) + id;
  }

  /*------------------------------------------------------------------------*/

  /**
   * Adds two numbers.
   *
   * @static
   * @memberOf _
   * @since 3.4.0
   * @category Math
   * @param {number} augend The first number in an addition.
   * @param {number} addend The second number in an addition.
   * @returns {number} Returns the total.
   * @example
   *
   * _.add(6, 4);
   * // => 10
   */
  var add = createMathOperation(function(augend, addend) {
    return augend + addend;
  }, 0);

  /**
   * Computes `number` rounded up to `precision`.
   *
   * @static
   * @memberOf _
   * @since 3.10.0
   * @category Math
   * @param {number} number The number to round up.
   * @param {number} [precision=0] The precision to round up to.
   * @returns {number} Returns the rounded up number.
   * @example
   *
   * _.ceil(4.006);
   * // => 5
   *
   * _.ceil(6.004, 2);
   * // => 6.01
   *
   * _.ceil(6040, -2);
   * // => 6100
   */
  var ceil = createRound('ceil');

  /**
   * Divide two numbers.
   *
   * @static
   * @memberOf _
   * @since 4.7.0
   * @category Math
   * @param {number} dividend The first number in a division.
   * @param {number} divisor The second number in a division.
   * @returns {number} Returns the quotient.
   * @example
   *
   * _.divide(6, 4);
   * // => 1.5
   */
  var divide = createMathOperation(function(dividend, divisor) {
    return dividend / divisor;
  }, 1);

  /**
   * Computes `number` rounded down to `precision`.
   *
   * @static
   * @memberOf _
   * @since 3.10.0
   * @category Math
   * @param {number} number The number to round down.
   * @param {number} [precision=0] The precision to round down to.
   * @returns {number} Returns the rounded down number.
   * @example
   *
   * _.floor(4.006);
   * // => 4
   *
   * _.floor(0.046, 2);
   * // => 0.04
   *
   * _.floor(4060, -2);
   * // => 4000
   */
  var floor = createRound('floor');

  /**
   * Computes the maximum value of `array`. If `array` is empty or falsey,
   * `undefined` is returned.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Math
   * @param {Array} array The array to iterate over.
   * @returns {*} Returns the maximum value.
   * @example
   *
   * _.max([4, 2, 8, 6]);
   * // => 8
   *
   * _.max([]);
   * // => undefined
   */
  function max(array) {
    return (array && array.length)
      ? baseExtremum(array, identity, baseGt)
      : undefined;
  }

  /**
   * This method is like `_.max` except that it accepts `iteratee` which is
   * invoked for each element in `array` to generate the criterion by which
   * the value is ranked. The iteratee is invoked with one argument: (value).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Math
   * @param {Array} array The array to iterate over.
   * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
   * @returns {*} Returns the maximum value.
   * @example
   *
   * var objects = [{ 'n': 1 }, { 'n': 2 }];
   *
   * _.maxBy(objects, function(o) { return o.n; });
   * // => { 'n': 2 }
   *
   * // The `_.property` iteratee shorthand.
   * _.maxBy(objects, 'n');
   * // => { 'n': 2 }
   */
  function maxBy(array, iteratee) {
    return (array && array.length)
      ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)
      : undefined;
  }

  /**
   * Computes the mean of the values in `array`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Math
   * @param {Array} array The array to iterate over.
   * @returns {number} Returns the mean.
   * @example
   *
   * _.mean([4, 2, 8, 6]);
   * // => 5
   */
  function mean(array) {
    return baseMean(array, identity);
  }

  /**
   * This method is like `_.mean` except that it accepts `iteratee` which is
   * invoked for each element in `array` to generate the value to be averaged.
   * The iteratee is invoked with one argument: (value).
   *
   * @static
   * @memberOf _
   * @since 4.7.0
   * @category Math
   * @param {Array} array The array to iterate over.
   * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
   * @returns {number} Returns the mean.
   * @example
   *
   * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
   *
   * _.meanBy(objects, function(o) { return o.n; });
   * // => 5
   *
   * // The `_.property` iteratee shorthand.
   * _.meanBy(objects, 'n');
   * // => 5
   */
  function meanBy(array, iteratee) {
    return baseMean(array, getIteratee(iteratee, 2));
  }

  /**
   * Computes the minimum value of `array`. If `array` is empty or falsey,
   * `undefined` is returned.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Math
   * @param {Array} array The array to iterate over.
   * @returns {*} Returns the minimum value.
   * @example
   *
   * _.min([4, 2, 8, 6]);
   * // => 2
   *
   * _.min([]);
   * // => undefined
   */
  function min(array) {
    return (array && array.length)
      ? baseExtremum(array, identity, baseLt)
      : undefined;
  }

  /**
   * This method is like `_.min` except that it accepts `iteratee` which is
   * invoked for each element in `array` to generate the criterion by which
   * the value is ranked. The iteratee is invoked with one argument: (value).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Math
   * @param {Array} array The array to iterate over.
   * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
   * @returns {*} Returns the minimum value.
   * @example
   *
   * var objects = [{ 'n': 1 }, { 'n': 2 }];
   *
   * _.minBy(objects, function(o) { return o.n; });
   * // => { 'n': 1 }
   *
   * // The `_.property` iteratee shorthand.
   * _.minBy(objects, 'n');
   * // => { 'n': 1 }
   */
  function minBy(array, iteratee) {
    return (array && array.length)
      ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)
      : undefined;
  }

  /**
   * Multiply two numbers.
   *
   * @static
   * @memberOf _
   * @since 4.7.0
   * @category Math
   * @param {number} multiplier The first number in a multiplication.
   * @param {number} multiplicand The second number in a multiplication.
   * @returns {number} Returns the product.
   * @example
   *
   * _.multiply(6, 4);
   * // => 24
   */
  var multiply = createMathOperation(function(multiplier, multiplicand) {
    return multiplier * multiplicand;
  }, 1);

  /**
   * Computes `number` rounded to `precision`.
   *
   * @static
   * @memberOf _
   * @since 3.10.0
   * @category Math
   * @param {number} number The number to round.
   * @param {number} [precision=0] The precision to round to.
   * @returns {number} Returns the rounded number.
   * @example
   *
   * _.round(4.006);
   * // => 4
   *
   * _.round(4.006, 2);
   * // => 4.01
   *
   * _.round(4060, -2);
   * // => 4100
   */
  var round = createRound('round');

  /**
   * Subtract two numbers.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Math
   * @param {number} minuend The first number in a subtraction.
   * @param {number} subtrahend The second number in a subtraction.
   * @returns {number} Returns the difference.
   * @example
   *
   * _.subtract(6, 4);
   * // => 2
   */
  var subtract = createMathOperation(function(minuend, subtrahend) {
    return minuend - subtrahend;
  }, 0);

  /**
   * Computes the sum of the values in `array`.
   *
   * @static
   * @memberOf _
   * @since 3.4.0
   * @category Math
   * @param {Array} array The array to iterate over.
   * @returns {number} Returns the sum.
   * @example
   *
   * _.sum([4, 2, 8, 6]);
   * // => 20
   */
  function sum(array) {
    return (array && array.length)
      ? baseSum(array, identity)
      : 0;
  }

  /**
   * This method is like `_.sum` except that it accepts `iteratee` which is
   * invoked for each element in `array` to generate the value to be summed.
   * The iteratee is invoked with one argument: (value).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Math
   * @param {Array} array The array to iterate over.
   * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
   * @returns {number} Returns the sum.
   * @example
   *
   * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
   *
   * _.sumBy(objects, function(o) { return o.n; });
   * // => 20
   *
   * // The `_.property` iteratee shorthand.
   * _.sumBy(objects, 'n');
   * // => 20
   */
  function sumBy(array, iteratee) {
    return (array && array.length)
      ? baseSum(array, getIteratee(iteratee, 2))
      : 0;
  }

  /*------------------------------------------------------------------------*/

  // Add methods that return wrapped values in chain sequences.
  lodash.after = after;
  lodash.ary = ary;
  lodash.assign = assign;
  lodash.assignIn = assignIn;
  lodash.assignInWith = assignInWith;
  lodash.assignWith = assignWith;
  lodash.at = at;
  lodash.before = before;
  lodash.bind = bind;
  lodash.bindAll = bindAll;
  lodash.bindKey = bindKey;
  lodash.castArray = castArray;
  lodash.chain = chain;
  lodash.chunk = chunk;
  lodash.compact = compact;
  lodash.concat = concat;
  lodash.cond = cond;
  lodash.conforms = conforms;
  lodash.constant = constant;
  lodash.countBy = countBy;
  lodash.create = create;
  lodash.curry = curry;
  lodash.curryRight = curryRight;
  lodash.debounce = debounce;
  lodash.defaults = defaults;
  lodash.defaultsDeep = defaultsDeep;
  lodash.defer = defer;
  lodash.delay = delay;
  lodash.difference = difference;
  lodash.differenceBy = differenceBy;
  lodash.differenceWith = differenceWith;
  lodash.drop = drop;
  lodash.dropRight = dropRight;
  lodash.dropRightWhile = dropRightWhile;
  lodash.dropWhile = dropWhile;
  lodash.fill = fill;
  lodash.filter = filter;
  lodash.flatMap = flatMap;
  lodash.flatMapDeep = flatMapDeep;
  lodash.flatMapDepth = flatMapDepth;
  lodash.flatten = flatten;
  lodash.flattenDeep = flattenDeep;
  lodash.flattenDepth = flattenDepth;
  lodash.flip = flip;
  lodash.flow = flow;
  lodash.flowRight = flowRight;
  lodash.fromPairs = fromPairs;
  lodash.functions = functions;
  lodash.functionsIn = functionsIn;
  lodash.groupBy = groupBy;
  lodash.initial = initial;
  lodash.intersection = intersection;
  lodash.intersectionBy = intersectionBy;
  lodash.intersectionWith = intersectionWith;
  lodash.invert = invert;
  lodash.invertBy = invertBy;
  lodash.invokeMap = invokeMap;
  lodash.iteratee = iteratee;
  lodash.keyBy = keyBy;
  lodash.keys = keys;
  lodash.keysIn = keysIn;
  lodash.map = map;
  lodash.mapKeys = mapKeys;
  lodash.mapValues = mapValues;
  lodash.matches = matches;
  lodash.matchesProperty = matchesProperty;
  lodash.memoize = memoize;
  lodash.merge = merge;
  lodash.mergeWith = mergeWith;
  lodash.method = method;
  lodash.methodOf = methodOf;
  lodash.mixin = mixin;
  lodash.negate = negate;
  lodash.nthArg = nthArg;
  lodash.omit = omit;
  lodash.omitBy = omitBy;
  lodash.once = once;
  lodash.orderBy = orderBy;
  lodash.over = over;
  lodash.overArgs = overArgs;
  lodash.overEvery = overEvery;
  lodash.overSome = overSome;
  lodash.partial = partial;
  lodash.partialRight = partialRight;
  lodash.partition = partition;
  lodash.pick = pick;
  lodash.pickBy = pickBy;
  lodash.property = property;
  lodash.propertyOf = propertyOf;
  lodash.pull = pull;
  lodash.pullAll = pullAll;
  lodash.pullAllBy = pullAllBy;
  lodash.pullAllWith = pullAllWith;
  lodash.pullAt = pullAt;
  lodash.range = range;
  lodash.rangeRight = rangeRight;
  lodash.rearg = rearg;
  lodash.reject = reject;
  lodash.remove = remove;
  lodash.rest = rest;
  lodash.reverse = reverse;
  lodash.sampleSize = sampleSize;
  lodash.set = set;
  lodash.setWith = setWith;
  lodash.shuffle = shuffle;
  lodash.slice = slice;
  lodash.sortBy = sortBy;
  lodash.sortedUniq = sortedUniq;
  lodash.sortedUniqBy = sortedUniqBy;
  lodash.split = split;
  lodash.spread = spread;
  lodash.tail = tail;
  lodash.take = take;
  lodash.takeRight = takeRight;
  lodash.takeRightWhile = takeRightWhile;
  lodash.takeWhile = takeWhile;
  lodash.tap = tap;
  lodash.throttle = throttle;
  lodash.thru = thru;
  lodash.toArray = toArray;
  lodash.toPairs = toPairs;
  lodash.toPairsIn = toPairsIn;
  lodash.toPath = toPath;
  lodash.toPlainObject = toPlainObject;
  lodash.transform = transform;
  lodash.unary = unary;
  lodash.union = union;
  lodash.unionBy = unionBy;
  lodash.unionWith = unionWith;
  lodash.uniq = uniq;
  lodash.uniqBy = uniqBy;
  lodash.uniqWith = uniqWith;
  lodash.unset = unset;
  lodash.unzip = unzip;
  lodash.unzipWith = unzipWith;
  lodash.update = update;
  lodash.updateWith = updateWith;
  lodash.values = values;
  lodash.valuesIn = valuesIn;
  lodash.without = without;
  lodash.words = words;
  lodash.wrap = wrap;
  lodash.xor = xor;
  lodash.xorBy = xorBy;
  lodash.xorWith = xorWith;
  lodash.zip = zip;
  lodash.zipObject = zipObject;
  lodash.zipObjectDeep = zipObjectDeep;
  lodash.zipWith = zipWith;

  // Add aliases.
  lodash.entries = toPairs;
  lodash.entriesIn = toPairsIn;
  lodash.extend = assignIn;
  lodash.extendWith = assignInWith;

  // Add methods to `lodash.prototype`.
  mixin(lodash, lodash);

  /*------------------------------------------------------------------------*/

  // Add methods that return unwrapped values in chain sequences.
  lodash.add = add;
  lodash.attempt = attempt;
  lodash.camelCase = camelCase;
  lodash.capitalize = capitalize;
  lodash.ceil = ceil;
  lodash.clamp = clamp;
  lodash.clone = clone;
  lodash.cloneDeep = cloneDeep;
  lodash.cloneDeepWith = cloneDeepWith;
  lodash.cloneWith = cloneWith;
  lodash.conformsTo = conformsTo;
  lodash.deburr = deburr;
  lodash.defaultTo = defaultTo;
  lodash.divide = divide;
  lodash.endsWith = endsWith;
  lodash.eq = eq;
  lodash.escape = escape;
  lodash.escapeRegExp = escapeRegExp;
  lodash.every = every;
  lodash.find = find;
  lodash.findIndex = findIndex;
  lodash.findKey = findKey;
  lodash.findLast = findLast;
  lodash.findLastIndex = findLastIndex;
  lodash.findLastKey = findLastKey;
  lodash.floor = floor;
  lodash.forEach = forEach;
  lodash.forEachRight = forEachRight;
  lodash.forIn = forIn;
  lodash.forInRight = forInRight;
  lodash.forOwn = forOwn;
  lodash.forOwnRight = forOwnRight;
  lodash.get = get;
  lodash.gt = gt;
  lodash.gte = gte;
  lodash.has = has;
  lodash.hasIn = hasIn;
  lodash.head = head;
  lodash.identity = identity;
  lodash.includes = includes;
  lodash.indexOf = indexOf;
  lodash.inRange = inRange;
  lodash.invoke = invoke;
  lodash.isArguments = isArguments;
  lodash.isArray = isArray;
  lodash.isArrayBuffer = isArrayBuffer;
  lodash.isArrayLike = isArrayLike;
  lodash.isArrayLikeObject = isArrayLikeObject;
  lodash.isBoolean = isBoolean;
  lodash.isBuffer = isBuffer;
  lodash.isDate = isDate;
  lodash.isElement = isElement;
  lodash.isEmpty = isEmpty;
  lodash.isEqual = isEqual;
  lodash.isEqualWith = isEqualWith;
  lodash.isError = isError;
  lodash.isFinite = isFinite;
  lodash.isFunction = isFunction;
  lodash.isInteger = isInteger;
  lodash.isLength = isLength;
  lodash.isMap = isMap;
  lodash.isMatch = isMatch;
  lodash.isMatchWith = isMatchWith;
  lodash.isNaN = isNaN;
  lodash.isNative = isNative;
  lodash.isNil = isNil;
  lodash.isNull = isNull;
  lodash.isNumber = isNumber;
  lodash.isObject = isObject;
  lodash.isObjectLike = isObjectLike;
  lodash.isPlainObject = isPlainObject;
  lodash.isRegExp = isRegExp;
  lodash.isSafeInteger = isSafeInteger;
  lodash.isSet = isSet;
  lodash.isString = isString;
  lodash.isSymbol = isSymbol;
  lodash.isTypedArray = isTypedArray;
  lodash.isUndefined = isUndefined;
  lodash.isWeakMap = isWeakMap;
  lodash.isWeakSet = isWeakSet;
  lodash.join = join;
  lodash.kebabCase = kebabCase;
  lodash.last = last;
  lodash.lastIndexOf = lastIndexOf;
  lodash.lowerCase = lowerCase;
  lodash.lowerFirst = lowerFirst;
  lodash.lt = lt;
  lodash.lte = lte;
  lodash.max = max;
  lodash.maxBy = maxBy;
  lodash.mean = mean;
  lodash.meanBy = meanBy;
  lodash.min = min;
  lodash.minBy = minBy;
  lodash.stubArray = stubArray;
  lodash.stubFalse = stubFalse;
  lodash.stubObject = stubObject;
  lodash.stubString = stubString;
  lodash.stubTrue = stubTrue;
  lodash.multiply = multiply;
  lodash.nth = nth;
  lodash.noConflict = noConflict;
  lodash.noop = noop;
  lodash.now = now;
  lodash.pad = pad;
  lodash.padEnd = padEnd;
  lodash.padStart = padStart;
  lodash.parseInt = parseInt;
  lodash.random = random;
  lodash.reduce = reduce;
  lodash.reduceRight = reduceRight;
  lodash.repeat = repeat;
  lodash.replace = replace;
  lodash.result = result;
  lodash.round = round;
  lodash.runInContext = runInContext;
  lodash.sample = sample;
  lodash.size = size;
  lodash.snakeCase = snakeCase;
  lodash.some = some;
  lodash.sortedIndex = sortedIndex;
  lodash.sortedIndexBy = sortedIndexBy;
  lodash.sortedIndexOf = sortedIndexOf;
  lodash.sortedLastIndex = sortedLastIndex;
  lodash.sortedLastIndexBy = sortedLastIndexBy;
  lodash.sortedLastIndexOf = sortedLastIndexOf;
  lodash.startCase = startCase;
  lodash.startsWith = startsWith;
  lodash.subtract = subtract;
  lodash.sum = sum;
  lodash.sumBy = sumBy;
  lodash.template = template;
  lodash.times = times;
  lodash.toFinite = toFinite;
  lodash.toInteger = toInteger;
  lodash.toLength = toLength;
  lodash.toLower = toLower;
  lodash.toNumber = toNumber;
  lodash.toSafeInteger = toSafeInteger;
  lodash.toString = toString;
  lodash.toUpper = toUpper;
  lodash.trim = trim;
  lodash.trimEnd = trimEnd;
  lodash.trimStart = trimStart;
  lodash.truncate = truncate;
  lodash.unescape = unescape;
  lodash.uniqueId = uniqueId;
  lodash.upperCase = upperCase;
  lodash.upperFirst = upperFirst;

  // Add aliases.
  lodash.each = forEach;
  lodash.eachRight = forEachRight;
  lodash.first = head;

  mixin(lodash, (function() {
    var source = {};
    baseForOwn(lodash, function(func, methodName) {
      if (!hasOwnProperty.call(lodash.prototype, methodName)) {
        source[methodName] = func;
      }
    });
    return source;
  }()), { 'chain': false });

  /*------------------------------------------------------------------------*/

  /**
   * The semantic version number.
   *
   * @static
   * @memberOf _
   * @type {string}
   */
  lodash.VERSION = VERSION;

  // Assign default placeholders.
  arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {
    lodash[methodName].placeholder = lodash;
  });

  // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.
  arrayEach(['drop', 'take'], function(methodName, index) {
    LazyWrapper.prototype[methodName] = function(n) {
      n = n === undefined ? 1 : nativeMax(toInteger(n), 0);

      var result = (this.__filtered__ && !index)
        ? new LazyWrapper(this)
        : this.clone();

      if (result.__filtered__) {
        result.__takeCount__ = nativeMin(n, result.__takeCount__);
      } else {
        result.__views__.push({
          'size': nativeMin(n, MAX_ARRAY_LENGTH),
          'type': methodName + (result.__dir__ < 0 ? 'Right' : '')
        });
      }
      return result;
    };

    LazyWrapper.prototype[methodName + 'Right'] = function(n) {
      return this.reverse()[methodName](n).reverse();
    };
  });

  // Add `LazyWrapper` methods that accept an `iteratee` value.
  arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {
    var type = index + 1,
        isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;

    LazyWrapper.prototype[methodName] = function(iteratee) {
      var result = this.clone();
      result.__iteratees__.push({
        'iteratee': getIteratee(iteratee, 3),
        'type': type
      });
      result.__filtered__ = result.__filtered__ || isFilter;
      return result;
    };
  });

  // Add `LazyWrapper` methods for `_.head` and `_.last`.
  arrayEach(['head', 'last'], function(methodName, index) {
    var takeName = 'take' + (index ? 'Right' : '');

    LazyWrapper.prototype[methodName] = function() {
      return this[takeName](1).value()[0];
    };
  });

  // Add `LazyWrapper` methods for `_.initial` and `_.tail`.
  arrayEach(['initial', 'tail'], function(methodName, index) {
    var dropName = 'drop' + (index ? '' : 'Right');

    LazyWrapper.prototype[methodName] = function() {
      return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
    };
  });

  LazyWrapper.prototype.compact = function() {
    return this.filter(identity);
  };

  LazyWrapper.prototype.find = function(predicate) {
    return this.filter(predicate).head();
  };

  LazyWrapper.prototype.findLast = function(predicate) {
    return this.reverse().find(predicate);
  };

  LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
    if (typeof path == 'function') {
      return new LazyWrapper(this);
    }
    return this.map(function(value) {
      return baseInvoke(value, path, args);
    });
  });

  LazyWrapper.prototype.reject = function(predicate) {
    return this.filter(negate(getIteratee(predicate)));
  };

  LazyWrapper.prototype.slice = function(start, end) {
    start = toInteger(start);

    var result = this;
    if (result.__filtered__ && (start > 0 || end < 0)) {
      return new LazyWrapper(result);
    }
    if (start < 0) {
      result = result.takeRight(-start);
    } else if (start) {
      result = result.drop(start);
    }
    if (end !== undefined) {
      end = toInteger(end);
      result = end < 0 ? result.dropRight(-end) : result.take(end - start);
    }
    return result;
  };

  LazyWrapper.prototype.takeRightWhile = function(predicate) {
    return this.reverse().takeWhile(predicate).reverse();
  };

  LazyWrapper.prototype.toArray = function() {
    return this.take(MAX_ARRAY_LENGTH);
  };

  // Add `LazyWrapper` methods to `lodash.prototype`.
  baseForOwn(LazyWrapper.prototype, function(func, methodName) {
    var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),
        isTaker = /^(?:head|last)$/.test(methodName),
        lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],
        retUnwrapped = isTaker || /^find/.test(methodName);

    if (!lodashFunc) {
      return;
    }
    lodash.prototype[methodName] = function() {
      var value = this.__wrapped__,
          args = isTaker ? [1] : arguments,
          isLazy = value instanceof LazyWrapper,
          iteratee = args[0],
          useLazy = isLazy || isArray(value);

      var interceptor = function(value) {
        var result = lodashFunc.apply(lodash, arrayPush([value], args));
        return (isTaker && chainAll) ? result[0] : result;
      };

      if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {
        // Avoid lazy use if the iteratee has a "length" value other than `1`.
        isLazy = useLazy = false;
      }
      var chainAll = this.__chain__,
          isHybrid = !!this.__actions__.length,
          isUnwrapped = retUnwrapped && !chainAll,
          onlyLazy = isLazy && !isHybrid;

      if (!retUnwrapped && useLazy) {
        value = onlyLazy ? value : new LazyWrapper(this);
        var result = func.apply(value, args);
        result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });
        return new LodashWrapper(result, chainAll);
      }
      if (isUnwrapped && onlyLazy) {
        return func.apply(this, args);
      }
      result = this.thru(interceptor);
      return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;
    };
  });

  // Add `Array` methods to `lodash.prototype`.
  arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {
    var func = arrayProto[methodName],
        chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',
        retUnwrapped = /^(?:pop|shift)$/.test(methodName);

    lodash.prototype[methodName] = function() {
      var args = arguments;
      if (retUnwrapped && !this.__chain__) {
        var value = this.value();
        return func.apply(isArray(value) ? value : [], args);
      }
      return this[chainName](function(value) {
        return func.apply(isArray(value) ? value : [], args);
      });
    };
  });

  // Map minified method names to their real names.
  baseForOwn(LazyWrapper.prototype, function(func, methodName) {
    var lodashFunc = lodash[methodName];
    if (lodashFunc) {
      var key = (lodashFunc.name + ''),
          names = realNames[key] || (realNames[key] = []);

      names.push({ 'name': methodName, 'func': lodashFunc });
    }
  });

  realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{
    'name': 'wrapper',
    'func': undefined
  }];

  // Add methods to `LazyWrapper`.
  LazyWrapper.prototype.clone = lazyClone;
  LazyWrapper.prototype.reverse = lazyReverse;
  LazyWrapper.prototype.value = lazyValue;

  // Add chain sequence methods to the `lodash` wrapper.
  lodash.prototype.at = wrapperAt;
  lodash.prototype.chain = wrapperChain;
  lodash.prototype.commit = wrapperCommit;
  lodash.prototype.next = wrapperNext;
  lodash.prototype.plant = wrapperPlant;
  lodash.prototype.reverse = wrapperReverse;
  lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;

  // Add lazy aliases.
  lodash.prototype.first = lodash.prototype.head;

  if (symIterator) {
    lodash.prototype[symIterator] = wrapperToIterator;
  }
  return lodash;
});

/*--------------------------------------------------------------------------*/

// Export lodash.
var _ = runInContext();

// Some AMD build optimizers, like r.js, check for condition patterns like:
if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
  // Expose Lodash on the global object to prevent errors when Lodash is
  // loaded by a script tag in the presence of an AMD loader.
  // See http://requirejs.org/docs/errors.html#mismatch for more details.
  // Use `_.noConflict` to remove Lodash from the global object.
  root._ = _;

  // Define as an anonymous module so, through path mapping, it can be
  // referenced as the "underscore" module.
  define(function() {
    return _;
  });
}
// Check for `exports` after `define` in case a build optimizer adds it.
else if (freeModule) {
  // Export for Node.js.
  (freeModule.exports = _)._ = _;
  // Export for CommonJS support.
  freeExports._ = _;
}
else {
  // Export to the global object.
  root._ = _;
}

}.call(this));

/* WEBPACK VAR INJECTION */}.call(exports, webpack_require(19), webpack_require(3)(module)))

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

/**

* This method returns the first argument it receives.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Util
* @param {*} value Any value.
* @returns {*} Returns `value`.
* @example
*
* var object = { 'a': 1 };
*
* console.log(_.identity(object) === object);
* // => true
*/

function identity(value) {

return value;

}

module.exports = identity;

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

var g;

// This works in non-strict mode g = (function() {

return this;

})();

try {

// This works if eval is allowed (see CSP)
g = g || Function("return this")() || (1,eval)("this");

} catch(e) {

// This works if the window reference is available
if(typeof window === "object")
        g = window;

}

// g can still be undefined, but nothing to do about it… // We return undefined, instead of nothing here, so it's // easier to handle this case. if(!global) { …}

module.exports = g;

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

/**

* Copyright (c) 2014, Chris Pettitt
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

var lib = webpack_require(205);

module.exports = {

Graph: lib.Graph,
json: __webpack_require__(207),
alg: __webpack_require__(208),
version: lib.version

};

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

var arrayLikeKeys = webpack_require(174),

baseKeys = __webpack_require__(235),
isArrayLike = __webpack_require__(13);

/**

* Creates an array of the own enumerable property names of `object`.
*
* **Note:** Non-object values are coerced to objects. See the
* [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
* for more details.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Object
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
* @example
*
* function Foo() {
*   this.a = 1;
*   this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.keys(new Foo);
* // => ['a', 'b'] (iteration order is not guaranteed)
*
* _.keys('hi');
* // => ['0', '1']
*/

function keys(object) {

return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);

}

module.exports = keys;

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

var root = webpack_require(5);

/** Built-in value references. */ var Symbol = root.Symbol;

module.exports = Symbol;

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

/**

* Performs a
* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* comparison between two values to determine if they are equivalent.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
* @example
*
* var object = { 'a': 1 };
* var other = { 'a': 1 };
*
* _.eq(object, object);
* // => true
*
* _.eq(object, other);
* // => false
*
* _.eq('a', 'a');
* // => true
*
* _.eq('a', Object('a'));
* // => false
*
* _.eq(NaN, NaN);
* // => true
*/

function eq(value, other) {

return value === other || (value !== value && other !== other);

}

module.exports = eq;

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

var listCacheClear = webpack_require(264),

listCacheDelete = __webpack_require__(265),
listCacheGet = __webpack_require__(266),
listCacheHas = __webpack_require__(267),
listCacheSet = __webpack_require__(268);

/**

* Creates an list cache object.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/

function ListCache(entries) {

var index = -1,
    length = entries == null ? 0 : entries.length;

this.clear();
while (++index < length) {
  var entry = entries[index];
  this.set(entry[0], entry[1]);
}

}

// Add methods to `ListCache`. ListCache.prototype.clear = listCacheClear; ListCache.prototype = listCacheDelete; ListCache.prototype.get = listCacheGet; ListCache.prototype.has = listCacheHas; ListCache.prototype.set = listCacheSet;

module.exports = ListCache;

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

var eq = webpack_require(23);

/**

* Gets the index at which the `key` is found in `array` of key-value pairs.
*
* @private
* @param {Array} array The array to inspect.
* @param {*} key The key to search for.
* @returns {number} Returns the index of the matched value, else `-1`.
*/

function assocIndexOf(array, key) {

var length = array.length;
while (length--) {
  if (eq(array[length][0], key)) {
    return length;
  }
}
return -1;

}

module.exports = assocIndexOf;

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

var getNative = webpack_require(10);

/* Built-in method references that are verified to be native. */ var nativeCreate = getNative(Object, 'create');

module.exports = nativeCreate;

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

var isKeyable = webpack_require(282);

/**

* Gets the data for `map`.
*
* @private
* @param {Object} map The map to query.
* @param {string} key The reference key.
* @returns {*} Returns the map data.
*/

function getMapData(map, key) {

var data = map.__data__;
return isKeyable(key)
  ? data[typeof key == 'string' ? 'string' : 'hash']
  : data.map;

}

module.exports = getMapData;

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

var isSymbol = webpack_require(16);

/** Used as references for various `Number` constants. */ var INFINITY = 1 / 0;

/**

* Converts `value` to a string key if it's not a string or symbol.
*
* @private
* @param {*} value The value to inspect.
* @returns {string|symbol} Returns the key.
*/

function toKey(value) {

if (typeof value == 'string' || isSymbol(value)) {
  return value;
}
var result = (value + '');
return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;

}

module.exports = toKey;

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

var WEBPACK_AMD_DEFINE_FACTORY, WEBPACK_AMD_DEFINE_RESULT;!function() {

var d3 = {
  version: "3.5.17"
};
var d3_arraySlice = [].slice, d3_array = function(list) {
  return d3_arraySlice.call(list);
};
var d3_document = this.document;
function d3_documentElement(node) {
  return node && (node.ownerDocument || node.document || node).documentElement;
}
function d3_window(node) {
  return node && (node.ownerDocument && node.ownerDocument.defaultView || node.document && node || node.defaultView);
}
if (d3_document) {
  try {
    d3_array(d3_document.documentElement.childNodes)[0].nodeType;
  } catch (e) {
    d3_array = function(list) {
      var i = list.length, array = new Array(i);
      while (i--) array[i] = list[i];
      return array;
    };
  }
}
if (!Date.now) Date.now = function() {
  return +new Date();
};
if (d3_document) {
  try {
    d3_document.createElement("DIV").style.setProperty("opacity", 0, "");
  } catch (error) {
    var d3_element_prototype = this.Element.prototype, d3_element_setAttribute = d3_element_prototype.setAttribute, d3_element_setAttributeNS = d3_element_prototype.setAttributeNS, d3_style_prototype = this.CSSStyleDeclaration.prototype, d3_style_setProperty = d3_style_prototype.setProperty;
    d3_element_prototype.setAttribute = function(name, value) {
      d3_element_setAttribute.call(this, name, value + "");
    };
    d3_element_prototype.setAttributeNS = function(space, local, value) {
      d3_element_setAttributeNS.call(this, space, local, value + "");
    };
    d3_style_prototype.setProperty = function(name, value, priority) {
      d3_style_setProperty.call(this, name, value + "", priority);
    };
  }
}
d3.ascending = d3_ascending;
function d3_ascending(a, b) {
  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
}
d3.descending = function(a, b) {
  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
};
d3.min = function(array, f) {
  var i = -1, n = array.length, a, b;
  if (arguments.length === 1) {
    while (++i < n) if ((b = array[i]) != null && b >= b) {
      a = b;
      break;
    }
    while (++i < n) if ((b = array[i]) != null && a > b) a = b;
  } else {
    while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {
      a = b;
      break;
    }
    while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;
  }
  return a;
};
d3.max = function(array, f) {
  var i = -1, n = array.length, a, b;
  if (arguments.length === 1) {
    while (++i < n) if ((b = array[i]) != null && b >= b) {
      a = b;
      break;
    }
    while (++i < n) if ((b = array[i]) != null && b > a) a = b;
  } else {
    while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {
      a = b;
      break;
    }
    while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;
  }
  return a;
};
d3.extent = function(array, f) {
  var i = -1, n = array.length, a, b, c;
  if (arguments.length === 1) {
    while (++i < n) if ((b = array[i]) != null && b >= b) {
      a = c = b;
      break;
    }
    while (++i < n) if ((b = array[i]) != null) {
      if (a > b) a = b;
      if (c < b) c = b;
    }
  } else {
    while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {
      a = c = b;
      break;
    }
    while (++i < n) if ((b = f.call(array, array[i], i)) != null) {
      if (a > b) a = b;
      if (c < b) c = b;
    }
  }
  return [ a, c ];
};
function d3_number(x) {
  return x === null ? NaN : +x;
}
function d3_numeric(x) {
  return !isNaN(x);
}
d3.sum = function(array, f) {
  var s = 0, n = array.length, a, i = -1;
  if (arguments.length === 1) {
    while (++i < n) if (d3_numeric(a = +array[i])) s += a;
  } else {
    while (++i < n) if (d3_numeric(a = +f.call(array, array[i], i))) s += a;
  }
  return s;
};
d3.mean = function(array, f) {
  var s = 0, n = array.length, a, i = -1, j = n;
  if (arguments.length === 1) {
    while (++i < n) if (d3_numeric(a = d3_number(array[i]))) s += a; else --j;
  } else {
    while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) s += a; else --j;
  }
  if (j) return s / j;
};
d3.quantile = function(values, p) {
  var H = (values.length - 1) * p + 1, h = Math.floor(H), v = +values[h - 1], e = H - h;
  return e ? v + e * (values[h] - v) : v;
};
d3.median = function(array, f) {
  var numbers = [], n = array.length, a, i = -1;
  if (arguments.length === 1) {
    while (++i < n) if (d3_numeric(a = d3_number(array[i]))) numbers.push(a);
  } else {
    while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) numbers.push(a);
  }
  if (numbers.length) return d3.quantile(numbers.sort(d3_ascending), .5);
};
d3.variance = function(array, f) {
  var n = array.length, m = 0, a, d, s = 0, i = -1, j = 0;
  if (arguments.length === 1) {
    while (++i < n) {
      if (d3_numeric(a = d3_number(array[i]))) {
        d = a - m;
        m += d / ++j;
        s += d * (a - m);
      }
    }
  } else {
    while (++i < n) {
      if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) {
        d = a - m;
        m += d / ++j;
        s += d * (a - m);
      }
    }
  }
  if (j > 1) return s / (j - 1);
};
d3.deviation = function() {
  var v = d3.variance.apply(this, arguments);
  return v ? Math.sqrt(v) : v;
};
function d3_bisector(compare) {
  return {
    left: function(a, x, lo, hi) {
      if (arguments.length < 3) lo = 0;
      if (arguments.length < 4) hi = a.length;
      while (lo < hi) {
        var mid = lo + hi >>> 1;
        if (compare(a[mid], x) < 0) lo = mid + 1; else hi = mid;
      }
      return lo;
    },
    right: function(a, x, lo, hi) {
      if (arguments.length < 3) lo = 0;
      if (arguments.length < 4) hi = a.length;
      while (lo < hi) {
        var mid = lo + hi >>> 1;
        if (compare(a[mid], x) > 0) hi = mid; else lo = mid + 1;
      }
      return lo;
    }
  };
}
var d3_bisect = d3_bisector(d3_ascending);
d3.bisectLeft = d3_bisect.left;
d3.bisect = d3.bisectRight = d3_bisect.right;
d3.bisector = function(f) {
  return d3_bisector(f.length === 1 ? function(d, x) {
    return d3_ascending(f(d), x);
  } : f);
};
d3.shuffle = function(array, i0, i1) {
  if ((m = arguments.length) < 3) {
    i1 = array.length;
    if (m < 2) i0 = 0;
  }
  var m = i1 - i0, t, i;
  while (m) {
    i = Math.random() * m-- | 0;
    t = array[m + i0], array[m + i0] = array[i + i0], array[i + i0] = t;
  }
  return array;
};
d3.permute = function(array, indexes) {
  var i = indexes.length, permutes = new Array(i);
  while (i--) permutes[i] = array[indexes[i]];
  return permutes;
};
d3.pairs = function(array) {
  var i = 0, n = array.length - 1, p0, p1 = array[0], pairs = new Array(n < 0 ? 0 : n);
  while (i < n) pairs[i] = [ p0 = p1, p1 = array[++i] ];
  return pairs;
};
d3.transpose = function(matrix) {
  if (!(n = matrix.length)) return [];
  for (var i = -1, m = d3.min(matrix, d3_transposeLength), transpose = new Array(m); ++i < m; ) {
    for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n; ) {
      row[j] = matrix[j][i];
    }
  }
  return transpose;
};
function d3_transposeLength(d) {
  return d.length;
}
d3.zip = function() {
  return d3.transpose(arguments);
};
d3.keys = function(map) {
  var keys = [];
  for (var key in map) keys.push(key);
  return keys;
};
d3.values = function(map) {
  var values = [];
  for (var key in map) values.push(map[key]);
  return values;
};
d3.entries = function(map) {
  var entries = [];
  for (var key in map) entries.push({
    key: key,
    value: map[key]
  });
  return entries;
};
d3.merge = function(arrays) {
  var n = arrays.length, m, i = -1, j = 0, merged, array;
  while (++i < n) j += arrays[i].length;
  merged = new Array(j);
  while (--n >= 0) {
    array = arrays[n];
    m = array.length;
    while (--m >= 0) {
      merged[--j] = array[m];
    }
  }
  return merged;
};
var abs = Math.abs;
d3.range = function(start, stop, step) {
  if (arguments.length < 3) {
    step = 1;
    if (arguments.length < 2) {
      stop = start;
      start = 0;
    }
  }
  if ((stop - start) / step === Infinity) throw new Error("infinite range");
  var range = [], k = d3_range_integerScale(abs(step)), i = -1, j;
  start *= k, stop *= k, step *= k;
  if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k); else while ((j = start + step * ++i) < stop) range.push(j / k);
  return range;
};
function d3_range_integerScale(x) {
  var k = 1;
  while (x * k % 1) k *= 10;
  return k;
}
function d3_class(ctor, properties) {
  for (var key in properties) {
    Object.defineProperty(ctor.prototype, key, {
      value: properties[key],
      enumerable: false
    });
  }
}
d3.map = function(object, f) {
  var map = new d3_Map();
  if (object instanceof d3_Map) {
    object.forEach(function(key, value) {
      map.set(key, value);
    });
  } else if (Array.isArray(object)) {
    var i = -1, n = object.length, o;
    if (arguments.length === 1) while (++i < n) map.set(i, object[i]); else while (++i < n) map.set(f.call(object, o = object[i], i), o);
  } else {
    for (var key in object) map.set(key, object[key]);
  }
  return map;
};
function d3_Map() {
  this._ = Object.create(null);
}
var d3_map_proto = "__proto__", d3_map_zero = "\x00";
d3_class(d3_Map, {
  has: d3_map_has,
  get: function(key) {
    return this._[d3_map_escape(key)];
  },
  set: function(key, value) {
    return this._[d3_map_escape(key)] = value;
  },
  remove: d3_map_remove,
  keys: d3_map_keys,
  values: function() {
    var values = [];
    for (var key in this._) values.push(this._[key]);
    return values;
  },
  entries: function() {
    var entries = [];
    for (var key in this._) entries.push({
      key: d3_map_unescape(key),
      value: this._[key]
    });
    return entries;
  },
  size: d3_map_size,
  empty: d3_map_empty,
  forEach: function(f) {
    for (var key in this._) f.call(this, d3_map_unescape(key), this._[key]);
  }
});
function d3_map_escape(key) {
  return (key += "") === d3_map_proto || key[0] === d3_map_zero ? d3_map_zero + key : key;
}
function d3_map_unescape(key) {
  return (key += "")[0] === d3_map_zero ? key.slice(1) : key;
}
function d3_map_has(key) {
  return d3_map_escape(key) in this._;
}
function d3_map_remove(key) {
  return (key = d3_map_escape(key)) in this._ && delete this._[key];
}
function d3_map_keys() {
  var keys = [];
  for (var key in this._) keys.push(d3_map_unescape(key));
  return keys;
}
function d3_map_size() {
  var size = 0;
  for (var key in this._) ++size;
  return size;
}
function d3_map_empty() {
  for (var key in this._) return false;
  return true;
}
d3.nest = function() {
  var nest = {}, keys = [], sortKeys = [], sortValues, rollup;
  function map(mapType, array, depth) {
    if (depth >= keys.length) return rollup ? rollup.call(nest, array) : sortValues ? array.sort(sortValues) : array;
    var i = -1, n = array.length, key = keys[depth++], keyValue, object, setter, valuesByKey = new d3_Map(), values;
    while (++i < n) {
      if (values = valuesByKey.get(keyValue = key(object = array[i]))) {
        values.push(object);
      } else {
        valuesByKey.set(keyValue, [ object ]);
      }
    }
    if (mapType) {
      object = mapType();
      setter = function(keyValue, values) {
        object.set(keyValue, map(mapType, values, depth));
      };
    } else {
      object = {};
      setter = function(keyValue, values) {
        object[keyValue] = map(mapType, values, depth);
      };
    }
    valuesByKey.forEach(setter);
    return object;
  }
  function entries(map, depth) {
    if (depth >= keys.length) return map;
    var array = [], sortKey = sortKeys[depth++];
    map.forEach(function(key, keyMap) {
      array.push({
        key: key,
        values: entries(keyMap, depth)
      });
    });
    return sortKey ? array.sort(function(a, b) {
      return sortKey(a.key, b.key);
    }) : array;
  }
  nest.map = function(array, mapType) {
    return map(mapType, array, 0);
  };
  nest.entries = function(array) {
    return entries(map(d3.map, array, 0), 0);
  };
  nest.key = function(d) {
    keys.push(d);
    return nest;
  };
  nest.sortKeys = function(order) {
    sortKeys[keys.length - 1] = order;
    return nest;
  };
  nest.sortValues = function(order) {
    sortValues = order;
    return nest;
  };
  nest.rollup = function(f) {
    rollup = f;
    return nest;
  };
  return nest;
};
d3.set = function(array) {
  var set = new d3_Set();
  if (array) for (var i = 0, n = array.length; i < n; ++i) set.add(array[i]);
  return set;
};
function d3_Set() {
  this._ = Object.create(null);
}
d3_class(d3_Set, {
  has: d3_map_has,
  add: function(key) {
    this._[d3_map_escape(key += "")] = true;
    return key;
  },
  remove: d3_map_remove,
  values: d3_map_keys,
  size: d3_map_size,
  empty: d3_map_empty,
  forEach: function(f) {
    for (var key in this._) f.call(this, d3_map_unescape(key));
  }
});
d3.behavior = {};
function d3_identity(d) {
  return d;
}
d3.rebind = function(target, source) {
  var i = 1, n = arguments.length, method;
  while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]);
  return target;
};
function d3_rebind(target, source, method) {
  return function() {
    var value = method.apply(source, arguments);
    return value === source ? target : value;
  };
}
function d3_vendorSymbol(object, name) {
  if (name in object) return name;
  name = name.charAt(0).toUpperCase() + name.slice(1);
  for (var i = 0, n = d3_vendorPrefixes.length; i < n; ++i) {
    var prefixName = d3_vendorPrefixes[i] + name;
    if (prefixName in object) return prefixName;
  }
}
var d3_vendorPrefixes = [ "webkit", "ms", "moz", "Moz", "o", "O" ];
function d3_noop() {}
d3.dispatch = function() {
  var dispatch = new d3_dispatch(), i = -1, n = arguments.length;
  while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
  return dispatch;
};
function d3_dispatch() {}
d3_dispatch.prototype.on = function(type, listener) {
  var i = type.indexOf("."), name = "";
  if (i >= 0) {
    name = type.slice(i + 1);
    type = type.slice(0, i);
  }
  if (type) return arguments.length < 2 ? this[type].on(name) : this[type].on(name, listener);
  if (arguments.length === 2) {
    if (listener == null) for (type in this) {
      if (this.hasOwnProperty(type)) this[type].on(name, null);
    }
    return this;
  }
};
function d3_dispatch_event(dispatch) {
  var listeners = [], listenerByName = new d3_Map();
  function event() {
    var z = listeners, i = -1, n = z.length, l;
    while (++i < n) if (l = z[i].on) l.apply(this, arguments);
    return dispatch;
  }
  event.on = function(name, listener) {
    var l = listenerByName.get(name), i;
    if (arguments.length < 2) return l && l.on;
    if (l) {
      l.on = null;
      listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1));
      listenerByName.remove(name);
    }
    if (listener) listeners.push(listenerByName.set(name, {
      on: listener
    }));
    return dispatch;
  };
  return event;
}
d3.event = null;
function d3_eventPreventDefault() {
  d3.event.preventDefault();
}
function d3_eventSource() {
  var e = d3.event, s;
  while (s = e.sourceEvent) e = s;
  return e;
}
function d3_eventDispatch(target) {
  var dispatch = new d3_dispatch(), i = 0, n = arguments.length;
  while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
  dispatch.of = function(thiz, argumentz) {
    return function(e1) {
      try {
        var e0 = e1.sourceEvent = d3.event;
        e1.target = target;
        d3.event = e1;
        dispatch[e1.type].apply(thiz, argumentz);
      } finally {
        d3.event = e0;
      }
    };
  };
  return dispatch;
}
d3.requote = function(s) {
  return s.replace(d3_requote_re, "\\$&");
};
var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;
var d3_subclass = {}.__proto__ ? function(object, prototype) {
  object.__proto__ = prototype;
} : function(object, prototype) {
  for (var property in prototype) object[property] = prototype[property];
};
function d3_selection(groups) {
  d3_subclass(groups, d3_selectionPrototype);
  return groups;
}
var d3_select = function(s, n) {
  return n.querySelector(s);
}, d3_selectAll = function(s, n) {
  return n.querySelectorAll(s);
}, d3_selectMatches = function(n, s) {
  var d3_selectMatcher = n.matches || n[d3_vendorSymbol(n, "matchesSelector")];
  d3_selectMatches = function(n, s) {
    return d3_selectMatcher.call(n, s);
  };
  return d3_selectMatches(n, s);
};
if (typeof Sizzle === "function") {
  d3_select = function(s, n) {
    return Sizzle(s, n)[0] || null;
  };
  d3_selectAll = Sizzle;
  d3_selectMatches = Sizzle.matchesSelector;
}
d3.selection = function() {
  return d3.select(d3_document.documentElement);
};
var d3_selectionPrototype = d3.selection.prototype = [];
d3_selectionPrototype.select = function(selector) {
  var subgroups = [], subgroup, subnode, group, node;
  selector = d3_selection_selector(selector);
  for (var j = -1, m = this.length; ++j < m; ) {
    subgroups.push(subgroup = []);
    subgroup.parentNode = (group = this[j]).parentNode;
    for (var i = -1, n = group.length; ++i < n; ) {
      if (node = group[i]) {
        subgroup.push(subnode = selector.call(node, node.__data__, i, j));
        if (subnode && "__data__" in node) subnode.__data__ = node.__data__;
      } else {
        subgroup.push(null);
      }
    }
  }
  return d3_selection(subgroups);
};
function d3_selection_selector(selector) {
  return typeof selector === "function" ? selector : function() {
    return d3_select(selector, this);
  };
}
d3_selectionPrototype.selectAll = function(selector) {
  var subgroups = [], subgroup, node;
  selector = d3_selection_selectorAll(selector);
  for (var j = -1, m = this.length; ++j < m; ) {
    for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
      if (node = group[i]) {
        subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i, j)));
        subgroup.parentNode = node;
      }
    }
  }
  return d3_selection(subgroups);
};
function d3_selection_selectorAll(selector) {
  return typeof selector === "function" ? selector : function() {
    return d3_selectAll(selector, this);
  };
}
var d3_nsXhtml = "http://www.w3.org/1999/xhtml";
var d3_nsPrefix = {
  svg: "http://www.w3.org/2000/svg",
  xhtml: d3_nsXhtml,
  xlink: "http://www.w3.org/1999/xlink",
  xml: "http://www.w3.org/XML/1998/namespace",
  xmlns: "http://www.w3.org/2000/xmlns/"
};
d3.ns = {
  prefix: d3_nsPrefix,
  qualify: function(name) {
    var i = name.indexOf(":"), prefix = name;
    if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1);
    return d3_nsPrefix.hasOwnProperty(prefix) ? {
      space: d3_nsPrefix[prefix],
      local: name
    } : name;
  }
};
d3_selectionPrototype.attr = function(name, value) {
  if (arguments.length < 2) {
    if (typeof name === "string") {
      var node = this.node();
      name = d3.ns.qualify(name);
      return name.local ? node.getAttributeNS(name.space, name.local) : node.getAttribute(name);
    }
    for (value in name) this.each(d3_selection_attr(value, name[value]));
    return this;
  }
  return this.each(d3_selection_attr(name, value));
};
function d3_selection_attr(name, value) {
  name = d3.ns.qualify(name);
  function attrNull() {
    this.removeAttribute(name);
  }
  function attrNullNS() {
    this.removeAttributeNS(name.space, name.local);
  }
  function attrConstant() {
    this.setAttribute(name, value);
  }
  function attrConstantNS() {
    this.setAttributeNS(name.space, name.local, value);
  }
  function attrFunction() {
    var x = value.apply(this, arguments);
    if (x == null) this.removeAttribute(name); else this.setAttribute(name, x);
  }
  function attrFunctionNS() {
    var x = value.apply(this, arguments);
    if (x == null) this.removeAttributeNS(name.space, name.local); else this.setAttributeNS(name.space, name.local, x);
  }
  return value == null ? name.local ? attrNullNS : attrNull : typeof value === "function" ? name.local ? attrFunctionNS : attrFunction : name.local ? attrConstantNS : attrConstant;
}
function d3_collapse(s) {
  return s.trim().replace(/\s+/g, " ");
}
d3_selectionPrototype.classed = function(name, value) {
  if (arguments.length < 2) {
    if (typeof name === "string") {
      var node = this.node(), n = (name = d3_selection_classes(name)).length, i = -1;
      if (value = node.classList) {
        while (++i < n) if (!value.contains(name[i])) return false;
      } else {
        value = node.getAttribute("class");
        while (++i < n) if (!d3_selection_classedRe(name[i]).test(value)) return false;
      }
      return true;
    }
    for (value in name) this.each(d3_selection_classed(value, name[value]));
    return this;
  }
  return this.each(d3_selection_classed(name, value));
};
function d3_selection_classedRe(name) {
  return new RegExp("(?:^|\\s+)" + d3.requote(name) + "(?:\\s+|$)", "g");
}
function d3_selection_classes(name) {
  return (name + "").trim().split(/^|\s+/);
}
function d3_selection_classed(name, value) {
  name = d3_selection_classes(name).map(d3_selection_classedName);
  var n = name.length;
  function classedConstant() {
    var i = -1;
    while (++i < n) name[i](this, value);
  }
  function classedFunction() {
    var i = -1, x = value.apply(this, arguments);
    while (++i < n) name[i](this, x);
  }
  return typeof value === "function" ? classedFunction : classedConstant;
}
function d3_selection_classedName(name) {
  var re = d3_selection_classedRe(name);
  return function(node, value) {
    if (c = node.classList) return value ? c.add(name) : c.remove(name);
    var c = node.getAttribute("class") || "";
    if (value) {
      re.lastIndex = 0;
      if (!re.test(c)) node.setAttribute("class", d3_collapse(c + " " + name));
    } else {
      node.setAttribute("class", d3_collapse(c.replace(re, " ")));
    }
  };
}
d3_selectionPrototype.style = function(name, value, priority) {
  var n = arguments.length;
  if (n < 3) {
    if (typeof name !== "string") {
      if (n < 2) value = "";
      for (priority in name) this.each(d3_selection_style(priority, name[priority], value));
      return this;
    }
    if (n < 2) {
      var node = this.node();
      return d3_window(node).getComputedStyle(node, null).getPropertyValue(name);
    }
    priority = "";
  }
  return this.each(d3_selection_style(name, value, priority));
};
function d3_selection_style(name, value, priority) {
  function styleNull() {
    this.style.removeProperty(name);
  }
  function styleConstant() {
    this.style.setProperty(name, value, priority);
  }
  function styleFunction() {
    var x = value.apply(this, arguments);
    if (x == null) this.style.removeProperty(name); else this.style.setProperty(name, x, priority);
  }
  return value == null ? styleNull : typeof value === "function" ? styleFunction : styleConstant;
}
d3_selectionPrototype.property = function(name, value) {
  if (arguments.length < 2) {
    if (typeof name === "string") return this.node()[name];
    for (value in name) this.each(d3_selection_property(value, name[value]));
    return this;
  }
  return this.each(d3_selection_property(name, value));
};
function d3_selection_property(name, value) {
  function propertyNull() {
    delete this[name];
  }
  function propertyConstant() {
    this[name] = value;
  }
  function propertyFunction() {
    var x = value.apply(this, arguments);
    if (x == null) delete this[name]; else this[name] = x;
  }
  return value == null ? propertyNull : typeof value === "function" ? propertyFunction : propertyConstant;
}
d3_selectionPrototype.text = function(value) {
  return arguments.length ? this.each(typeof value === "function" ? function() {
    var v = value.apply(this, arguments);
    this.textContent = v == null ? "" : v;
  } : value == null ? function() {
    this.textContent = "";
  } : function() {
    this.textContent = value;
  }) : this.node().textContent;
};
d3_selectionPrototype.html = function(value) {
  return arguments.length ? this.each(typeof value === "function" ? function() {
    var v = value.apply(this, arguments);
    this.innerHTML = v == null ? "" : v;
  } : value == null ? function() {
    this.innerHTML = "";
  } : function() {
    this.innerHTML = value;
  }) : this.node().innerHTML;
};
d3_selectionPrototype.append = function(name) {
  name = d3_selection_creator(name);
  return this.select(function() {
    return this.appendChild(name.apply(this, arguments));
  });
};
function d3_selection_creator(name) {
  function create() {
    var document = this.ownerDocument, namespace = this.namespaceURI;
    return namespace === d3_nsXhtml && document.documentElement.namespaceURI === d3_nsXhtml ? document.createElement(name) : document.createElementNS(namespace, name);
  }
  function createNS() {
    return this.ownerDocument.createElementNS(name.space, name.local);
  }
  return typeof name === "function" ? name : (name = d3.ns.qualify(name)).local ? createNS : create;
}
d3_selectionPrototype.insert = function(name, before) {
  name = d3_selection_creator(name);
  before = d3_selection_selector(before);
  return this.select(function() {
    return this.insertBefore(name.apply(this, arguments), before.apply(this, arguments) || null);
  });
};
d3_selectionPrototype.remove = function() {
  return this.each(d3_selectionRemove);
};
function d3_selectionRemove() {
  var parent = this.parentNode;
  if (parent) parent.removeChild(this);
}
d3_selectionPrototype.data = function(value, key) {
  var i = -1, n = this.length, group, node;
  if (!arguments.length) {
    value = new Array(n = (group = this[0]).length);
    while (++i < n) {
      if (node = group[i]) {
        value[i] = node.__data__;
      }
    }
    return value;
  }
  function bind(group, groupData) {
    var i, n = group.length, m = groupData.length, n0 = Math.min(n, m), updateNodes = new Array(m), enterNodes = new Array(m), exitNodes = new Array(n), node, nodeData;
    if (key) {
      var nodeByKeyValue = new d3_Map(), keyValues = new Array(n), keyValue;
      for (i = -1; ++i < n; ) {
        if (node = group[i]) {
          if (nodeByKeyValue.has(keyValue = key.call(node, node.__data__, i))) {
            exitNodes[i] = node;
          } else {
            nodeByKeyValue.set(keyValue, node);
          }
          keyValues[i] = keyValue;
        }
      }
      for (i = -1; ++i < m; ) {
        if (!(node = nodeByKeyValue.get(keyValue = key.call(groupData, nodeData = groupData[i], i)))) {
          enterNodes[i] = d3_selection_dataNode(nodeData);
        } else if (node !== true) {
          updateNodes[i] = node;
          node.__data__ = nodeData;
        }
        nodeByKeyValue.set(keyValue, true);
      }
      for (i = -1; ++i < n; ) {
        if (i in keyValues && nodeByKeyValue.get(keyValues[i]) !== true) {
          exitNodes[i] = group[i];
        }
      }
    } else {
      for (i = -1; ++i < n0; ) {
        node = group[i];
        nodeData = groupData[i];
        if (node) {
          node.__data__ = nodeData;
          updateNodes[i] = node;
        } else {
          enterNodes[i] = d3_selection_dataNode(nodeData);
        }
      }
      for (;i < m; ++i) {
        enterNodes[i] = d3_selection_dataNode(groupData[i]);
      }
      for (;i < n; ++i) {
        exitNodes[i] = group[i];
      }
    }
    enterNodes.update = updateNodes;
    enterNodes.parentNode = updateNodes.parentNode = exitNodes.parentNode = group.parentNode;
    enter.push(enterNodes);
    update.push(updateNodes);
    exit.push(exitNodes);
  }
  var enter = d3_selection_enter([]), update = d3_selection([]), exit = d3_selection([]);
  if (typeof value === "function") {
    while (++i < n) {
      bind(group = this[i], value.call(group, group.parentNode.__data__, i));
    }
  } else {
    while (++i < n) {
      bind(group = this[i], value);
    }
  }
  update.enter = function() {
    return enter;
  };
  update.exit = function() {
    return exit;
  };
  return update;
};
function d3_selection_dataNode(data) {
  return {
    __data__: data
  };
}
d3_selectionPrototype.datum = function(value) {
  return arguments.length ? this.property("__data__", value) : this.property("__data__");
};
d3_selectionPrototype.filter = function(filter) {
  var subgroups = [], subgroup, group, node;
  if (typeof filter !== "function") filter = d3_selection_filter(filter);
  for (var j = 0, m = this.length; j < m; j++) {
    subgroups.push(subgroup = []);
    subgroup.parentNode = (group = this[j]).parentNode;
    for (var i = 0, n = group.length; i < n; i++) {
      if ((node = group[i]) && filter.call(node, node.__data__, i, j)) {
        subgroup.push(node);
      }
    }
  }
  return d3_selection(subgroups);
};
function d3_selection_filter(selector) {
  return function() {
    return d3_selectMatches(this, selector);
  };
}
d3_selectionPrototype.order = function() {
  for (var j = -1, m = this.length; ++j < m; ) {
    for (var group = this[j], i = group.length - 1, next = group[i], node; --i >= 0; ) {
      if (node = group[i]) {
        if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);
        next = node;
      }
    }
  }
  return this;
};
d3_selectionPrototype.sort = function(comparator) {
  comparator = d3_selection_sortComparator.apply(this, arguments);
  for (var j = -1, m = this.length; ++j < m; ) this[j].sort(comparator);
  return this.order();
};
function d3_selection_sortComparator(comparator) {
  if (!arguments.length) comparator = d3_ascending;
  return function(a, b) {
    return a && b ? comparator(a.__data__, b.__data__) : !a - !b;
  };
}
d3_selectionPrototype.each = function(callback) {
  return d3_selection_each(this, function(node, i, j) {
    callback.call(node, node.__data__, i, j);
  });
};
function d3_selection_each(groups, callback) {
  for (var j = 0, m = groups.length; j < m; j++) {
    for (var group = groups[j], i = 0, n = group.length, node; i < n; i++) {
      if (node = group[i]) callback(node, i, j);
    }
  }
  return groups;
}
d3_selectionPrototype.call = function(callback) {
  var args = d3_array(arguments);
  callback.apply(args[0] = this, args);
  return this;
};
d3_selectionPrototype.empty = function() {
  return !this.node();
};
d3_selectionPrototype.node = function() {
  for (var j = 0, m = this.length; j < m; j++) {
    for (var group = this[j], i = 0, n = group.length; i < n; i++) {
      var node = group[i];
      if (node) return node;
    }
  }
  return null;
};
d3_selectionPrototype.size = function() {
  var n = 0;
  d3_selection_each(this, function() {
    ++n;
  });
  return n;
};
function d3_selection_enter(selection) {
  d3_subclass(selection, d3_selection_enterPrototype);
  return selection;
}
var d3_selection_enterPrototype = [];
d3.selection.enter = d3_selection_enter;
d3.selection.enter.prototype = d3_selection_enterPrototype;
d3_selection_enterPrototype.append = d3_selectionPrototype.append;
d3_selection_enterPrototype.empty = d3_selectionPrototype.empty;
d3_selection_enterPrototype.node = d3_selectionPrototype.node;
d3_selection_enterPrototype.call = d3_selectionPrototype.call;
d3_selection_enterPrototype.size = d3_selectionPrototype.size;
d3_selection_enterPrototype.select = function(selector) {
  var subgroups = [], subgroup, subnode, upgroup, group, node;
  for (var j = -1, m = this.length; ++j < m; ) {
    upgroup = (group = this[j]).update;
    subgroups.push(subgroup = []);
    subgroup.parentNode = group.parentNode;
    for (var i = -1, n = group.length; ++i < n; ) {
      if (node = group[i]) {
        subgroup.push(upgroup[i] = subnode = selector.call(group.parentNode, node.__data__, i, j));
        subnode.__data__ = node.__data__;
      } else {
        subgroup.push(null);
      }
    }
  }
  return d3_selection(subgroups);
};
d3_selection_enterPrototype.insert = function(name, before) {
  if (arguments.length < 2) before = d3_selection_enterInsertBefore(this);
  return d3_selectionPrototype.insert.call(this, name, before);
};
function d3_selection_enterInsertBefore(enter) {
  var i0, j0;
  return function(d, i, j) {
    var group = enter[j].update, n = group.length, node;
    if (j != j0) j0 = j, i0 = 0;
    if (i >= i0) i0 = i + 1;
    while (!(node = group[i0]) && ++i0 < n) ;
    return node;
  };
}
d3.select = function(node) {
  var group;
  if (typeof node === "string") {
    group = [ d3_select(node, d3_document) ];
    group.parentNode = d3_document.documentElement;
  } else {
    group = [ node ];
    group.parentNode = d3_documentElement(node);
  }
  return d3_selection([ group ]);
};
d3.selectAll = function(nodes) {
  var group;
  if (typeof nodes === "string") {
    group = d3_array(d3_selectAll(nodes, d3_document));
    group.parentNode = d3_document.documentElement;
  } else {
    group = d3_array(nodes);
    group.parentNode = null;
  }
  return d3_selection([ group ]);
};
d3_selectionPrototype.on = function(type, listener, capture) {
  var n = arguments.length;
  if (n < 3) {
    if (typeof type !== "string") {
      if (n < 2) listener = false;
      for (capture in type) this.each(d3_selection_on(capture, type[capture], listener));
      return this;
    }
    if (n < 2) return (n = this.node()["__on" + type]) && n._;
    capture = false;
  }
  return this.each(d3_selection_on(type, listener, capture));
};
function d3_selection_on(type, listener, capture) {
  var name = "__on" + type, i = type.indexOf("."), wrap = d3_selection_onListener;
  if (i > 0) type = type.slice(0, i);
  var filter = d3_selection_onFilters.get(type);
  if (filter) type = filter, wrap = d3_selection_onFilter;
  function onRemove() {
    var l = this[name];
    if (l) {
      this.removeEventListener(type, l, l.$);
      delete this[name];
    }
  }
  function onAdd() {
    var l = wrap(listener, d3_array(arguments));
    onRemove.call(this);
    this.addEventListener(type, this[name] = l, l.$ = capture);
    l._ = listener;
  }
  function removeAll() {
    var re = new RegExp("^__on([^.]+)" + d3.requote(type) + "$"), match;
    for (var name in this) {
      if (match = name.match(re)) {
        var l = this[name];
        this.removeEventListener(match[1], l, l.$);
        delete this[name];
      }
    }
  }
  return i ? listener ? onAdd : onRemove : listener ? d3_noop : removeAll;
}
var d3_selection_onFilters = d3.map({
  mouseenter: "mouseover",
  mouseleave: "mouseout"
});
if (d3_document) {
  d3_selection_onFilters.forEach(function(k) {
    if ("on" + k in d3_document) d3_selection_onFilters.remove(k);
  });
}
function d3_selection_onListener(listener, argumentz) {
  return function(e) {
    var o = d3.event;
    d3.event = e;
    argumentz[0] = this.__data__;
    try {
      listener.apply(this, argumentz);
    } finally {
      d3.event = o;
    }
  };
}
function d3_selection_onFilter(listener, argumentz) {
  var l = d3_selection_onListener(listener, argumentz);
  return function(e) {
    var target = this, related = e.relatedTarget;
    if (!related || related !== target && !(related.compareDocumentPosition(target) & 8)) {
      l.call(target, e);
    }
  };
}
var d3_event_dragSelect, d3_event_dragId = 0;
function d3_event_dragSuppress(node) {
  var name = ".dragsuppress-" + ++d3_event_dragId, click = "click" + name, w = d3.select(d3_window(node)).on("touchmove" + name, d3_eventPreventDefault).on("dragstart" + name, d3_eventPreventDefault).on("selectstart" + name, d3_eventPreventDefault);
  if (d3_event_dragSelect == null) {
    d3_event_dragSelect = "onselectstart" in node ? false : d3_vendorSymbol(node.style, "userSelect");
  }
  if (d3_event_dragSelect) {
    var style = d3_documentElement(node).style, select = style[d3_event_dragSelect];
    style[d3_event_dragSelect] = "none";
  }
  return function(suppressClick) {
    w.on(name, null);
    if (d3_event_dragSelect) style[d3_event_dragSelect] = select;
    if (suppressClick) {
      var off = function() {
        w.on(click, null);
      };
      w.on(click, function() {
        d3_eventPreventDefault();
        off();
      }, true);
      setTimeout(off, 0);
    }
  };
}
d3.mouse = function(container) {
  return d3_mousePoint(container, d3_eventSource());
};
var d3_mouse_bug44083 = this.navigator && /WebKit/.test(this.navigator.userAgent) ? -1 : 0;
function d3_mousePoint(container, e) {
  if (e.changedTouches) e = e.changedTouches[0];
  var svg = container.ownerSVGElement || container;
  if (svg.createSVGPoint) {
    var point = svg.createSVGPoint();
    if (d3_mouse_bug44083 < 0) {
      var window = d3_window(container);
      if (window.scrollX || window.scrollY) {
        svg = d3.select("body").append("svg").style({
          position: "absolute",
          top: 0,
          left: 0,
          margin: 0,
          padding: 0,
          border: "none"
        }, "important");
        var ctm = svg[0][0].getScreenCTM();
        d3_mouse_bug44083 = !(ctm.f || ctm.e);
        svg.remove();
      }
    }
    if (d3_mouse_bug44083) point.x = e.pageX, point.y = e.pageY; else point.x = e.clientX, 
    point.y = e.clientY;
    point = point.matrixTransform(container.getScreenCTM().inverse());
    return [ point.x, point.y ];
  }
  var rect = container.getBoundingClientRect();
  return [ e.clientX - rect.left - container.clientLeft, e.clientY - rect.top - container.clientTop ];
}
d3.touch = function(container, touches, identifier) {
  if (arguments.length < 3) identifier = touches, touches = d3_eventSource().changedTouches;
  if (touches) for (var i = 0, n = touches.length, touch; i < n; ++i) {
    if ((touch = touches[i]).identifier === identifier) {
      return d3_mousePoint(container, touch);
    }
  }
};
d3.behavior.drag = function() {
  var event = d3_eventDispatch(drag, "drag", "dragstart", "dragend"), origin = null, mousedown = dragstart(d3_noop, d3.mouse, d3_window, "mousemove", "mouseup"), touchstart = dragstart(d3_behavior_dragTouchId, d3.touch, d3_identity, "touchmove", "touchend");
  function drag() {
    this.on("mousedown.drag", mousedown).on("touchstart.drag", touchstart);
  }
  function dragstart(id, position, subject, move, end) {
    return function() {
      var that = this, target = d3.event.target.correspondingElement || d3.event.target, parent = that.parentNode, dispatch = event.of(that, arguments), dragged = 0, dragId = id(), dragName = ".drag" + (dragId == null ? "" : "-" + dragId), dragOffset, dragSubject = d3.select(subject(target)).on(move + dragName, moved).on(end + dragName, ended), dragRestore = d3_event_dragSuppress(target), position0 = position(parent, dragId);
      if (origin) {
        dragOffset = origin.apply(that, arguments);
        dragOffset = [ dragOffset.x - position0[0], dragOffset.y - position0[1] ];
      } else {
        dragOffset = [ 0, 0 ];
      }
      dispatch({
        type: "dragstart"
      });
      function moved() {
        var position1 = position(parent, dragId), dx, dy;
        if (!position1) return;
        dx = position1[0] - position0[0];
        dy = position1[1] - position0[1];
        dragged |= dx | dy;
        position0 = position1;
        dispatch({
          type: "drag",
          x: position1[0] + dragOffset[0],
          y: position1[1] + dragOffset[1],
          dx: dx,
          dy: dy
        });
      }
      function ended() {
        if (!position(parent, dragId)) return;
        dragSubject.on(move + dragName, null).on(end + dragName, null);
        dragRestore(dragged);
        dispatch({
          type: "dragend"
        });
      }
    };
  }
  drag.origin = function(x) {
    if (!arguments.length) return origin;
    origin = x;
    return drag;
  };
  return d3.rebind(drag, event, "on");
};
function d3_behavior_dragTouchId() {
  return d3.event.changedTouches[0].identifier;
}
d3.touches = function(container, touches) {
  if (arguments.length < 2) touches = d3_eventSource().touches;
  return touches ? d3_array(touches).map(function(touch) {
    var point = d3_mousePoint(container, touch);
    point.identifier = touch.identifier;
    return point;
  }) : [];
};
var ε = 1e-6, ε2 = ε * ε, π = Math.PI, τ = 2 * π, τε = τ - ε, halfπ = π / 2, d3_radians = π / 180, d3_degrees = 180 / π;
function d3_sgn(x) {
  return x > 0 ? 1 : x < 0 ? -1 : 0;
}
function d3_cross2d(a, b, c) {
  return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
}
function d3_acos(x) {
  return x > 1 ? 0 : x < -1 ? π : Math.acos(x);
}
function d3_asin(x) {
  return x > 1 ? halfπ : x < -1 ? -halfπ : Math.asin(x);
}
function d3_sinh(x) {
  return ((x = Math.exp(x)) - 1 / x) / 2;
}
function d3_cosh(x) {
  return ((x = Math.exp(x)) + 1 / x) / 2;
}
function d3_tanh(x) {
  return ((x = Math.exp(2 * x)) - 1) / (x + 1);
}
function d3_haversin(x) {
  return (x = Math.sin(x / 2)) * x;
}
var ρ = Math.SQRT2, ρ2 = 2, ρ4 = 4;
d3.interpolateZoom = function(p0, p1) {
  var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], ux1 = p1[0], uy1 = p1[1], w1 = p1[2], dx = ux1 - ux0, dy = uy1 - uy0, d2 = dx * dx + dy * dy, i, S;
  if (d2 < ε2) {
    S = Math.log(w1 / w0) / ρ;
    i = function(t) {
      return [ ux0 + t * dx, uy0 + t * dy, w0 * Math.exp(ρ * t * S) ];
    };
  } else {
    var d1 = Math.sqrt(d2), b0 = (w1 * w1 - w0 * w0 + ρ4 * d2) / (2 * w0 * ρ2 * d1), b1 = (w1 * w1 - w0 * w0 - ρ4 * d2) / (2 * w1 * ρ2 * d1), r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);
    S = (r1 - r0) / ρ;
    i = function(t) {
      var s = t * S, coshr0 = d3_cosh(r0), u = w0 / (ρ2 * d1) * (coshr0 * d3_tanh(ρ * s + r0) - d3_sinh(r0));
      return [ ux0 + u * dx, uy0 + u * dy, w0 * coshr0 / d3_cosh(ρ * s + r0) ];
    };
  }
  i.duration = S * 1e3;
  return i;
};
d3.behavior.zoom = function() {
  var view = {
    x: 0,
    y: 0,
    k: 1
  }, translate0, center0, center, size = [ 960, 500 ], scaleExtent = d3_behavior_zoomInfinity, duration = 250, zooming = 0, mousedown = "mousedown.zoom", mousemove = "mousemove.zoom", mouseup = "mouseup.zoom", mousewheelTimer, touchstart = "touchstart.zoom", touchtime, event = d3_eventDispatch(zoom, "zoomstart", "zoom", "zoomend"), x0, x1, y0, y1;
  if (!d3_behavior_zoomWheel) {
    d3_behavior_zoomWheel = "onwheel" in d3_document ? (d3_behavior_zoomDelta = function() {
      return -d3.event.deltaY * (d3.event.deltaMode ? 120 : 1);
    }, "wheel") : "onmousewheel" in d3_document ? (d3_behavior_zoomDelta = function() {
      return d3.event.wheelDelta;
    }, "mousewheel") : (d3_behavior_zoomDelta = function() {
      return -d3.event.detail;
    }, "MozMousePixelScroll");
  }
  function zoom(g) {
    g.on(mousedown, mousedowned).on(d3_behavior_zoomWheel + ".zoom", mousewheeled).on("dblclick.zoom", dblclicked).on(touchstart, touchstarted);
  }
  zoom.event = function(g) {
    g.each(function() {
      var dispatch = event.of(this, arguments), view1 = view;
      if (d3_transitionInheritId) {
        d3.select(this).transition().each("start.zoom", function() {
          view = this.__chart__ || {
            x: 0,
            y: 0,
            k: 1
          };
          zoomstarted(dispatch);
        }).tween("zoom:zoom", function() {
          var dx = size[0], dy = size[1], cx = center0 ? center0[0] : dx / 2, cy = center0 ? center0[1] : dy / 2, i = d3.interpolateZoom([ (cx - view.x) / view.k, (cy - view.y) / view.k, dx / view.k ], [ (cx - view1.x) / view1.k, (cy - view1.y) / view1.k, dx / view1.k ]);
          return function(t) {
            var l = i(t), k = dx / l[2];
            this.__chart__ = view = {
              x: cx - l[0] * k,
              y: cy - l[1] * k,
              k: k
            };
            zoomed(dispatch);
          };
        }).each("interrupt.zoom", function() {
          zoomended(dispatch);
        }).each("end.zoom", function() {
          zoomended(dispatch);
        });
      } else {
        this.__chart__ = view;
        zoomstarted(dispatch);
        zoomed(dispatch);
        zoomended(dispatch);
      }
    });
  };
  zoom.translate = function(_) {
    if (!arguments.length) return [ view.x, view.y ];
    view = {
      x: +_[0],
      y: +_[1],
      k: view.k
    };
    rescale();
    return zoom;
  };
  zoom.scale = function(_) {
    if (!arguments.length) return view.k;
    view = {
      x: view.x,
      y: view.y,
      k: null
    };
    scaleTo(+_);
    rescale();
    return zoom;
  };
  zoom.scaleExtent = function(_) {
    if (!arguments.length) return scaleExtent;
    scaleExtent = _ == null ? d3_behavior_zoomInfinity : [ +_[0], +_[1] ];
    return zoom;
  };
  zoom.center = function(_) {
    if (!arguments.length) return center;
    center = _ && [ +_[0], +_[1] ];
    return zoom;
  };
  zoom.size = function(_) {
    if (!arguments.length) return size;
    size = _ && [ +_[0], +_[1] ];
    return zoom;
  };
  zoom.duration = function(_) {
    if (!arguments.length) return duration;
    duration = +_;
    return zoom;
  };
  zoom.x = function(z) {
    if (!arguments.length) return x1;
    x1 = z;
    x0 = z.copy();
    view = {
      x: 0,
      y: 0,
      k: 1
    };
    return zoom;
  };
  zoom.y = function(z) {
    if (!arguments.length) return y1;
    y1 = z;
    y0 = z.copy();
    view = {
      x: 0,
      y: 0,
      k: 1
    };
    return zoom;
  };
  function location(p) {
    return [ (p[0] - view.x) / view.k, (p[1] - view.y) / view.k ];
  }
  function point(l) {
    return [ l[0] * view.k + view.x, l[1] * view.k + view.y ];
  }
  function scaleTo(s) {
    view.k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s));
  }
  function translateTo(p, l) {
    l = point(l);
    view.x += p[0] - l[0];
    view.y += p[1] - l[1];
  }
  function zoomTo(that, p, l, k) {
    that.__chart__ = {
      x: view.x,
      y: view.y,
      k: view.k
    };
    scaleTo(Math.pow(2, k));
    translateTo(center0 = p, l);
    that = d3.select(that);
    if (duration > 0) that = that.transition().duration(duration);
    that.call(zoom.event);
  }
  function rescale() {
    if (x1) x1.domain(x0.range().map(function(x) {
      return (x - view.x) / view.k;
    }).map(x0.invert));
    if (y1) y1.domain(y0.range().map(function(y) {
      return (y - view.y) / view.k;
    }).map(y0.invert));
  }
  function zoomstarted(dispatch) {
    if (!zooming++) dispatch({
      type: "zoomstart"
    });
  }
  function zoomed(dispatch) {
    rescale();
    dispatch({
      type: "zoom",
      scale: view.k,
      translate: [ view.x, view.y ]
    });
  }
  function zoomended(dispatch) {
    if (!--zooming) dispatch({
      type: "zoomend"
    }), center0 = null;
  }
  function mousedowned() {
    var that = this, dispatch = event.of(that, arguments), dragged = 0, subject = d3.select(d3_window(that)).on(mousemove, moved).on(mouseup, ended), location0 = location(d3.mouse(that)), dragRestore = d3_event_dragSuppress(that);
    d3_selection_interrupt.call(that);
    zoomstarted(dispatch);
    function moved() {
      dragged = 1;
      translateTo(d3.mouse(that), location0);
      zoomed(dispatch);
    }
    function ended() {
      subject.on(mousemove, null).on(mouseup, null);
      dragRestore(dragged);
      zoomended(dispatch);
    }
  }
  function touchstarted() {
    var that = this, dispatch = event.of(that, arguments), locations0 = {}, distance0 = 0, scale0, zoomName = ".zoom-" + d3.event.changedTouches[0].identifier, touchmove = "touchmove" + zoomName, touchend = "touchend" + zoomName, targets = [], subject = d3.select(that), dragRestore = d3_event_dragSuppress(that);
    started();
    zoomstarted(dispatch);
    subject.on(mousedown, null).on(touchstart, started);
    function relocate() {
      var touches = d3.touches(that);
      scale0 = view.k;
      touches.forEach(function(t) {
        if (t.identifier in locations0) locations0[t.identifier] = location(t);
      });
      return touches;
    }
    function started() {
      var target = d3.event.target;
      d3.select(target).on(touchmove, moved).on(touchend, ended);
      targets.push(target);
      var changed = d3.event.changedTouches;
      for (var i = 0, n = changed.length; i < n; ++i) {
        locations0[changed[i].identifier] = null;
      }
      var touches = relocate(), now = Date.now();
      if (touches.length === 1) {
        if (now - touchtime < 500) {
          var p = touches[0];
          zoomTo(that, p, locations0[p.identifier], Math.floor(Math.log(view.k) / Math.LN2) + 1);
          d3_eventPreventDefault();
        }
        touchtime = now;
      } else if (touches.length > 1) {
        var p = touches[0], q = touches[1], dx = p[0] - q[0], dy = p[1] - q[1];
        distance0 = dx * dx + dy * dy;
      }
    }
    function moved() {
      var touches = d3.touches(that), p0, l0, p1, l1;
      d3_selection_interrupt.call(that);
      for (var i = 0, n = touches.length; i < n; ++i, l1 = null) {
        p1 = touches[i];
        if (l1 = locations0[p1.identifier]) {
          if (l0) break;
          p0 = p1, l0 = l1;
        }
      }
      if (l1) {
        var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1, scale1 = distance0 && Math.sqrt(distance1 / distance0);
        p0 = [ (p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2 ];
        l0 = [ (l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2 ];
        scaleTo(scale1 * scale0);
      }
      touchtime = null;
      translateTo(p0, l0);
      zoomed(dispatch);
    }
    function ended() {
      if (d3.event.touches.length) {
        var changed = d3.event.changedTouches;
        for (var i = 0, n = changed.length; i < n; ++i) {
          delete locations0[changed[i].identifier];
        }
        for (var identifier in locations0) {
          return void relocate();
        }
      }
      d3.selectAll(targets).on(zoomName, null);
      subject.on(mousedown, mousedowned).on(touchstart, touchstarted);
      dragRestore();
      zoomended(dispatch);
    }
  }
  function mousewheeled() {
    var dispatch = event.of(this, arguments);
    if (mousewheelTimer) clearTimeout(mousewheelTimer); else d3_selection_interrupt.call(this), 
    translate0 = location(center0 = center || d3.mouse(this)), zoomstarted(dispatch);
    mousewheelTimer = setTimeout(function() {
      mousewheelTimer = null;
      zoomended(dispatch);
    }, 50);
    d3_eventPreventDefault();
    scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * view.k);
    translateTo(center0, translate0);
    zoomed(dispatch);
  }
  function dblclicked() {
    var p = d3.mouse(this), k = Math.log(view.k) / Math.LN2;
    zoomTo(this, p, location(p), d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1);
  }
  return d3.rebind(zoom, event, "on");
};
var d3_behavior_zoomInfinity = [ 0, Infinity ], d3_behavior_zoomDelta, d3_behavior_zoomWheel;
d3.color = d3_color;
function d3_color() {}
d3_color.prototype.toString = function() {
  return this.rgb() + "";
};
d3.hsl = d3_hsl;
function d3_hsl(h, s, l) {
  return this instanceof d3_hsl ? void (this.h = +h, this.s = +s, this.l = +l) : arguments.length < 2 ? h instanceof d3_hsl ? new d3_hsl(h.h, h.s, h.l) : d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl) : new d3_hsl(h, s, l);
}
var d3_hslPrototype = d3_hsl.prototype = new d3_color();
d3_hslPrototype.brighter = function(k) {
  k = Math.pow(.7, arguments.length ? k : 1);
  return new d3_hsl(this.h, this.s, this.l / k);
};
d3_hslPrototype.darker = function(k) {
  k = Math.pow(.7, arguments.length ? k : 1);
  return new d3_hsl(this.h, this.s, k * this.l);
};
d3_hslPrototype.rgb = function() {
  return d3_hsl_rgb(this.h, this.s, this.l);
};
function d3_hsl_rgb(h, s, l) {
  var m1, m2;
  h = isNaN(h) ? 0 : (h %= 360) < 0 ? h + 360 : h;
  s = isNaN(s) ? 0 : s < 0 ? 0 : s > 1 ? 1 : s;
  l = l < 0 ? 0 : l > 1 ? 1 : l;
  m2 = l <= .5 ? l * (1 + s) : l + s - l * s;
  m1 = 2 * l - m2;
  function v(h) {
    if (h > 360) h -= 360; else if (h < 0) h += 360;
    if (h < 60) return m1 + (m2 - m1) * h / 60;
    if (h < 180) return m2;
    if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60;
    return m1;
  }
  function vv(h) {
    return Math.round(v(h) * 255);
  }
  return new d3_rgb(vv(h + 120), vv(h), vv(h - 120));
}
d3.hcl = d3_hcl;
function d3_hcl(h, c, l) {
  return this instanceof d3_hcl ? void (this.h = +h, this.c = +c, this.l = +l) : arguments.length < 2 ? h instanceof d3_hcl ? new d3_hcl(h.h, h.c, h.l) : h instanceof d3_lab ? d3_lab_hcl(h.l, h.a, h.b) : d3_lab_hcl((h = d3_rgb_lab((h = d3.rgb(h)).r, h.g, h.b)).l, h.a, h.b) : new d3_hcl(h, c, l);
}
var d3_hclPrototype = d3_hcl.prototype = new d3_color();
d3_hclPrototype.brighter = function(k) {
  return new d3_hcl(this.h, this.c, Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)));
};
d3_hclPrototype.darker = function(k) {
  return new d3_hcl(this.h, this.c, Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)));
};
d3_hclPrototype.rgb = function() {
  return d3_hcl_lab(this.h, this.c, this.l).rgb();
};
function d3_hcl_lab(h, c, l) {
  if (isNaN(h)) h = 0;
  if (isNaN(c)) c = 0;
  return new d3_lab(l, Math.cos(h *= d3_radians) * c, Math.sin(h) * c);
}
d3.lab = d3_lab;
function d3_lab(l, a, b) {
  return this instanceof d3_lab ? void (this.l = +l, this.a = +a, this.b = +b) : arguments.length < 2 ? l instanceof d3_lab ? new d3_lab(l.l, l.a, l.b) : l instanceof d3_hcl ? d3_hcl_lab(l.h, l.c, l.l) : d3_rgb_lab((l = d3_rgb(l)).r, l.g, l.b) : new d3_lab(l, a, b);
}
var d3_lab_K = 18;
var d3_lab_X = .95047, d3_lab_Y = 1, d3_lab_Z = 1.08883;
var d3_labPrototype = d3_lab.prototype = new d3_color();
d3_labPrototype.brighter = function(k) {
  return new d3_lab(Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)), this.a, this.b);
};
d3_labPrototype.darker = function(k) {
  return new d3_lab(Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)), this.a, this.b);
};
d3_labPrototype.rgb = function() {
  return d3_lab_rgb(this.l, this.a, this.b);
};
function d3_lab_rgb(l, a, b) {
  var y = (l + 16) / 116, x = y + a / 500, z = y - b / 200;
  x = d3_lab_xyz(x) * d3_lab_X;
  y = d3_lab_xyz(y) * d3_lab_Y;
  z = d3_lab_xyz(z) * d3_lab_Z;
  return new d3_rgb(d3_xyz_rgb(3.2404542 * x - 1.5371385 * y - .4985314 * z), d3_xyz_rgb(-.969266 * x + 1.8760108 * y + .041556 * z), d3_xyz_rgb(.0556434 * x - .2040259 * y + 1.0572252 * z));
}
function d3_lab_hcl(l, a, b) {
  return l > 0 ? new d3_hcl(Math.atan2(b, a) * d3_degrees, Math.sqrt(a * a + b * b), l) : new d3_hcl(NaN, NaN, l);
}
function d3_lab_xyz(x) {
  return x > .206893034 ? x * x * x : (x - 4 / 29) / 7.787037;
}
function d3_xyz_lab(x) {
  return x > .008856 ? Math.pow(x, 1 / 3) : 7.787037 * x + 4 / 29;
}
function d3_xyz_rgb(r) {
  return Math.round(255 * (r <= .00304 ? 12.92 * r : 1.055 * Math.pow(r, 1 / 2.4) - .055));
}
d3.rgb = d3_rgb;
function d3_rgb(r, g, b) {
  return this instanceof d3_rgb ? void (this.r = ~~r, this.g = ~~g, this.b = ~~b) : arguments.length < 2 ? r instanceof d3_rgb ? new d3_rgb(r.r, r.g, r.b) : d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb) : new d3_rgb(r, g, b);
}
function d3_rgbNumber(value) {
  return new d3_rgb(value >> 16, value >> 8 & 255, value & 255);
}
function d3_rgbString(value) {
  return d3_rgbNumber(value) + "";
}
var d3_rgbPrototype = d3_rgb.prototype = new d3_color();
d3_rgbPrototype.brighter = function(k) {
  k = Math.pow(.7, arguments.length ? k : 1);
  var r = this.r, g = this.g, b = this.b, i = 30;
  if (!r && !g && !b) return new d3_rgb(i, i, i);
  if (r && r < i) r = i;
  if (g && g < i) g = i;
  if (b && b < i) b = i;
  return new d3_rgb(Math.min(255, r / k), Math.min(255, g / k), Math.min(255, b / k));
};
d3_rgbPrototype.darker = function(k) {
  k = Math.pow(.7, arguments.length ? k : 1);
  return new d3_rgb(k * this.r, k * this.g, k * this.b);
};
d3_rgbPrototype.hsl = function() {
  return d3_rgb_hsl(this.r, this.g, this.b);
};
d3_rgbPrototype.toString = function() {
  return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b);
};
function d3_rgb_hex(v) {
  return v < 16 ? "0" + Math.max(0, v).toString(16) : Math.min(255, v).toString(16);
}
function d3_rgb_parse(format, rgb, hsl) {
  var r = 0, g = 0, b = 0, m1, m2, color;
  m1 = /([a-z]+)\((.*)\)/.exec(format = format.toLowerCase());
  if (m1) {
    m2 = m1[2].split(",");
    switch (m1[1]) {
     case "hsl":
      {
        return hsl(parseFloat(m2[0]), parseFloat(m2[1]) / 100, parseFloat(m2[2]) / 100);
      }

     case "rgb":
      {
        return rgb(d3_rgb_parseNumber(m2[0]), d3_rgb_parseNumber(m2[1]), d3_rgb_parseNumber(m2[2]));
      }
    }
  }
  if (color = d3_rgb_names.get(format)) {
    return rgb(color.r, color.g, color.b);
  }
  if (format != null && format.charAt(0) === "#" && !isNaN(color = parseInt(format.slice(1), 16))) {
    if (format.length === 4) {
      r = (color & 3840) >> 4;
      r = r >> 4 | r;
      g = color & 240;
      g = g >> 4 | g;
      b = color & 15;
      b = b << 4 | b;
    } else if (format.length === 7) {
      r = (color & 16711680) >> 16;
      g = (color & 65280) >> 8;
      b = color & 255;
    }
  }
  return rgb(r, g, b);
}
function d3_rgb_hsl(r, g, b) {
  var min = Math.min(r /= 255, g /= 255, b /= 255), max = Math.max(r, g, b), d = max - min, h, s, l = (max + min) / 2;
  if (d) {
    s = l < .5 ? d / (max + min) : d / (2 - max - min);
    if (r == max) h = (g - b) / d + (g < b ? 6 : 0); else if (g == max) h = (b - r) / d + 2; else h = (r - g) / d + 4;
    h *= 60;
  } else {
    h = NaN;
    s = l > 0 && l < 1 ? 0 : h;
  }
  return new d3_hsl(h, s, l);
}
function d3_rgb_lab(r, g, b) {
  r = d3_rgb_xyz(r);
  g = d3_rgb_xyz(g);
  b = d3_rgb_xyz(b);
  var x = d3_xyz_lab((.4124564 * r + .3575761 * g + .1804375 * b) / d3_lab_X), y = d3_xyz_lab((.2126729 * r + .7151522 * g + .072175 * b) / d3_lab_Y), z = d3_xyz_lab((.0193339 * r + .119192 * g + .9503041 * b) / d3_lab_Z);
  return d3_lab(116 * y - 16, 500 * (x - y), 200 * (y - z));
}
function d3_rgb_xyz(r) {
  return (r /= 255) <= .04045 ? r / 12.92 : Math.pow((r + .055) / 1.055, 2.4);
}
function d3_rgb_parseNumber(c) {
  var f = parseFloat(c);
  return c.charAt(c.length - 1) === "%" ? Math.round(f * 2.55) : f;
}
var d3_rgb_names = d3.map({
  aliceblue: 15792383,
  antiquewhite: 16444375,
  aqua: 65535,
  aquamarine: 8388564,
  azure: 15794175,
  beige: 16119260,
  bisque: 16770244,
  black: 0,
  blanchedalmond: 16772045,
  blue: 255,
  blueviolet: 9055202,
  brown: 10824234,
  burlywood: 14596231,
  cadetblue: 6266528,
  chartreuse: 8388352,
  chocolate: 13789470,
  coral: 16744272,
  cornflowerblue: 6591981,
  cornsilk: 16775388,
  crimson: 14423100,
  cyan: 65535,
  darkblue: 139,
  darkcyan: 35723,
  darkgoldenrod: 12092939,
  darkgray: 11119017,
  darkgreen: 25600,
  darkgrey: 11119017,
  darkkhaki: 12433259,
  darkmagenta: 9109643,
  darkolivegreen: 5597999,
  darkorange: 16747520,
  darkorchid: 10040012,
  darkred: 9109504,
  darksalmon: 15308410,
  darkseagreen: 9419919,
  darkslateblue: 4734347,
  darkslategray: 3100495,
  darkslategrey: 3100495,
  darkturquoise: 52945,
  darkviolet: 9699539,
  deeppink: 16716947,
  deepskyblue: 49151,
  dimgray: 6908265,
  dimgrey: 6908265,
  dodgerblue: 2003199,
  firebrick: 11674146,
  floralwhite: 16775920,
  forestgreen: 2263842,
  fuchsia: 16711935,
  gainsboro: 14474460,
  ghostwhite: 16316671,
  gold: 16766720,
  goldenrod: 14329120,
  gray: 8421504,
  green: 32768,
  greenyellow: 11403055,
  grey: 8421504,
  honeydew: 15794160,
  hotpink: 16738740,
  indianred: 13458524,
  indigo: 4915330,
  ivory: 16777200,
  khaki: 15787660,
  lavender: 15132410,
  lavenderblush: 16773365,
  lawngreen: 8190976,
  lemonchiffon: 16775885,
  lightblue: 11393254,
  lightcoral: 15761536,
  lightcyan: 14745599,
  lightgoldenrodyellow: 16448210,
  lightgray: 13882323,
  lightgreen: 9498256,
  lightgrey: 13882323,
  lightpink: 16758465,
  lightsalmon: 16752762,
  lightseagreen: 2142890,
  lightskyblue: 8900346,
  lightslategray: 7833753,
  lightslategrey: 7833753,
  lightsteelblue: 11584734,
  lightyellow: 16777184,
  lime: 65280,
  limegreen: 3329330,
  linen: 16445670,
  magenta: 16711935,
  maroon: 8388608,
  mediumaquamarine: 6737322,
  mediumblue: 205,
  mediumorchid: 12211667,
  mediumpurple: 9662683,
  mediumseagreen: 3978097,
  mediumslateblue: 8087790,
  mediumspringgreen: 64154,
  mediumturquoise: 4772300,
  mediumvioletred: 13047173,
  midnightblue: 1644912,
  mintcream: 16121850,
  mistyrose: 16770273,
  moccasin: 16770229,
  navajowhite: 16768685,
  navy: 128,
  oldlace: 16643558,
  olive: 8421376,
  olivedrab: 7048739,
  orange: 16753920,
  orangered: 16729344,
  orchid: 14315734,
  palegoldenrod: 15657130,
  palegreen: 10025880,
  paleturquoise: 11529966,
  palevioletred: 14381203,
  papayawhip: 16773077,
  peachpuff: 16767673,
  peru: 13468991,
  pink: 16761035,
  plum: 14524637,
  powderblue: 11591910,
  purple: 8388736,
  rebeccapurple: 6697881,
  red: 16711680,
  rosybrown: 12357519,
  royalblue: 4286945,
  saddlebrown: 9127187,
  salmon: 16416882,
  sandybrown: 16032864,
  seagreen: 3050327,
  seashell: 16774638,
  sienna: 10506797,
  silver: 12632256,
  skyblue: 8900331,
  slateblue: 6970061,
  slategray: 7372944,
  slategrey: 7372944,
  snow: 16775930,
  springgreen: 65407,
  steelblue: 4620980,
  tan: 13808780,
  teal: 32896,
  thistle: 14204888,
  tomato: 16737095,
  turquoise: 4251856,
  violet: 15631086,
  wheat: 16113331,
  white: 16777215,
  whitesmoke: 16119285,
  yellow: 16776960,
  yellowgreen: 10145074
});
d3_rgb_names.forEach(function(key, value) {
  d3_rgb_names.set(key, d3_rgbNumber(value));
});
function d3_functor(v) {
  return typeof v === "function" ? v : function() {
    return v;
  };
}
d3.functor = d3_functor;
d3.xhr = d3_xhrType(d3_identity);
function d3_xhrType(response) {
  return function(url, mimeType, callback) {
    if (arguments.length === 2 && typeof mimeType === "function") callback = mimeType, 
    mimeType = null;
    return d3_xhr(url, mimeType, response, callback);
  };
}
function d3_xhr(url, mimeType, response, callback) {
  var xhr = {}, dispatch = d3.dispatch("beforesend", "progress", "load", "error"), headers = {}, request = new XMLHttpRequest(), responseType = null;
  if (this.XDomainRequest && !("withCredentials" in request) && /^(http(s)?:)?\/\//.test(url)) request = new XDomainRequest();
  "onload" in request ? request.onload = request.onerror = respond : request.onreadystatechange = function() {
    request.readyState > 3 && respond();
  };
  function respond() {
    var status = request.status, result;
    if (!status && d3_xhrHasResponse(request) || status >= 200 && status < 300 || status === 304) {
      try {
        result = response.call(xhr, request);
      } catch (e) {
        dispatch.error.call(xhr, e);
        return;
      }
      dispatch.load.call(xhr, result);
    } else {
      dispatch.error.call(xhr, request);
    }
  }
  request.onprogress = function(event) {
    var o = d3.event;
    d3.event = event;
    try {
      dispatch.progress.call(xhr, request);
    } finally {
      d3.event = o;
    }
  };
  xhr.header = function(name, value) {
    name = (name + "").toLowerCase();
    if (arguments.length < 2) return headers[name];
    if (value == null) delete headers[name]; else headers[name] = value + "";
    return xhr;
  };
  xhr.mimeType = function(value) {
    if (!arguments.length) return mimeType;
    mimeType = value == null ? null : value + "";
    return xhr;
  };
  xhr.responseType = function(value) {
    if (!arguments.length) return responseType;
    responseType = value;
    return xhr;
  };
  xhr.response = function(value) {
    response = value;
    return xhr;
  };
  [ "get", "post" ].forEach(function(method) {
    xhr[method] = function() {
      return xhr.send.apply(xhr, [ method ].concat(d3_array(arguments)));
    };
  });
  xhr.send = function(method, data, callback) {
    if (arguments.length === 2 && typeof data === "function") callback = data, data = null;
    request.open(method, url, true);
    if (mimeType != null && !("accept" in headers)) headers["accept"] = mimeType + ",*/*";
    if (request.setRequestHeader) for (var name in headers) request.setRequestHeader(name, headers[name]);
    if (mimeType != null && request.overrideMimeType) request.overrideMimeType(mimeType);
    if (responseType != null) request.responseType = responseType;
    if (callback != null) xhr.on("error", callback).on("load", function(request) {
      callback(null, request);
    });
    dispatch.beforesend.call(xhr, request);
    request.send(data == null ? null : data);
    return xhr;
  };
  xhr.abort = function() {
    request.abort();
    return xhr;
  };
  d3.rebind(xhr, dispatch, "on");
  return callback == null ? xhr : xhr.get(d3_xhr_fixCallback(callback));
}
function d3_xhr_fixCallback(callback) {
  return callback.length === 1 ? function(error, request) {
    callback(error == null ? request : null);
  } : callback;
}
function d3_xhrHasResponse(request) {
  var type = request.responseType;
  return type && type !== "text" ? request.response : request.responseText;
}
d3.dsv = function(delimiter, mimeType) {
  var reFormat = new RegExp('["' + delimiter + "\n]"), delimiterCode = delimiter.charCodeAt(0);
  function dsv(url, row, callback) {
    if (arguments.length < 3) callback = row, row = null;
    var xhr = d3_xhr(url, mimeType, row == null ? response : typedResponse(row), callback);
    xhr.row = function(_) {
      return arguments.length ? xhr.response((row = _) == null ? response : typedResponse(_)) : row;
    };
    return xhr;
  }
  function response(request) {
    return dsv.parse(request.responseText);
  }
  function typedResponse(f) {
    return function(request) {
      return dsv.parse(request.responseText, f);
    };
  }
  dsv.parse = function(text, f) {
    var o;
    return dsv.parseRows(text, function(row, i) {
      if (o) return o(row, i - 1);
      var a = new Function("d", "return {" + row.map(function(name, i) {
        return JSON.stringify(name) + ": d[" + i + "]";
      }).join(",") + "}");
      o = f ? function(row, i) {
        return f(a(row), i);
      } : a;
    });
  };
  dsv.parseRows = function(text, f) {
    var EOL = {}, EOF = {}, rows = [], N = text.length, I = 0, n = 0, t, eol;
    function token() {
      if (I >= N) return EOF;
      if (eol) return eol = false, EOL;
      var j = I;
      if (text.charCodeAt(j) === 34) {
        var i = j;
        while (i++ < N) {
          if (text.charCodeAt(i) === 34) {
            if (text.charCodeAt(i + 1) !== 34) break;
            ++i;
          }
        }
        I = i + 2;
        var c = text.charCodeAt(i + 1);
        if (c === 13) {
          eol = true;
          if (text.charCodeAt(i + 2) === 10) ++I;
        } else if (c === 10) {
          eol = true;
        }
        return text.slice(j + 1, i).replace(/""/g, '"');
      }
      while (I < N) {
        var c = text.charCodeAt(I++), k = 1;
        if (c === 10) eol = true; else if (c === 13) {
          eol = true;
          if (text.charCodeAt(I) === 10) ++I, ++k;
        } else if (c !== delimiterCode) continue;
        return text.slice(j, I - k);
      }
      return text.slice(j);
    }
    while ((t = token()) !== EOF) {
      var a = [];
      while (t !== EOL && t !== EOF) {
        a.push(t);
        t = token();
      }
      if (f && (a = f(a, n++)) == null) continue;
      rows.push(a);
    }
    return rows;
  };
  dsv.format = function(rows) {
    if (Array.isArray(rows[0])) return dsv.formatRows(rows);
    var fieldSet = new d3_Set(), fields = [];
    rows.forEach(function(row) {
      for (var field in row) {
        if (!fieldSet.has(field)) {
          fields.push(fieldSet.add(field));
        }
      }
    });
    return [ fields.map(formatValue).join(delimiter) ].concat(rows.map(function(row) {
      return fields.map(function(field) {
        return formatValue(row[field]);
      }).join(delimiter);
    })).join("\n");
  };
  dsv.formatRows = function(rows) {
    return rows.map(formatRow).join("\n");
  };
  function formatRow(row) {
    return row.map(formatValue).join(delimiter);
  }
  function formatValue(text) {
    return reFormat.test(text) ? '"' + text.replace(/\"/g, '""') + '"' : text;
  }
  return dsv;
};
d3.csv = d3.dsv(",", "text/csv");
d3.tsv = d3.dsv("     ", "text/tab-separated-values");
var d3_timer_queueHead, d3_timer_queueTail, d3_timer_interval, d3_timer_timeout, d3_timer_frame = this[d3_vendorSymbol(this, "requestAnimationFrame")] || function(callback) {
  setTimeout(callback, 17);
};
d3.timer = function() {
  d3_timer.apply(this, arguments);
};
function d3_timer(callback, delay, then) {
  var n = arguments.length;
  if (n < 2) delay = 0;
  if (n < 3) then = Date.now();
  var time = then + delay, timer = {
    c: callback,
    t: time,
    n: null
  };
  if (d3_timer_queueTail) d3_timer_queueTail.n = timer; else d3_timer_queueHead = timer;
  d3_timer_queueTail = timer;
  if (!d3_timer_interval) {
    d3_timer_timeout = clearTimeout(d3_timer_timeout);
    d3_timer_interval = 1;
    d3_timer_frame(d3_timer_step);
  }
  return timer;
}
function d3_timer_step() {
  var now = d3_timer_mark(), delay = d3_timer_sweep() - now;
  if (delay > 24) {
    if (isFinite(delay)) {
      clearTimeout(d3_timer_timeout);
      d3_timer_timeout = setTimeout(d3_timer_step, delay);
    }
    d3_timer_interval = 0;
  } else {
    d3_timer_interval = 1;
    d3_timer_frame(d3_timer_step);
  }
}
d3.timer.flush = function() {
  d3_timer_mark();
  d3_timer_sweep();
};
function d3_timer_mark() {
  var now = Date.now(), timer = d3_timer_queueHead;
  while (timer) {
    if (now >= timer.t && timer.c(now - timer.t)) timer.c = null;
    timer = timer.n;
  }
  return now;
}
function d3_timer_sweep() {
  var t0, t1 = d3_timer_queueHead, time = Infinity;
  while (t1) {
    if (t1.c) {
      if (t1.t < time) time = t1.t;
      t1 = (t0 = t1).n;
    } else {
      t1 = t0 ? t0.n = t1.n : d3_timer_queueHead = t1.n;
    }
  }
  d3_timer_queueTail = t0;
  return time;
}
function d3_format_precision(x, p) {
  return p - (x ? Math.ceil(Math.log(x) / Math.LN10) : 1);
}
d3.round = function(x, n) {
  return n ? Math.round(x * (n = Math.pow(10, n))) / n : Math.round(x);
};
var d3_formatPrefixes = [ "y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y" ].map(d3_formatPrefix);
d3.formatPrefix = function(value, precision) {
  var i = 0;
  if (value = +value) {
    if (value < 0) value *= -1;
    if (precision) value = d3.round(value, d3_format_precision(value, precision));
    i = 1 + Math.floor(1e-12 + Math.log(value) / Math.LN10);
    i = Math.max(-24, Math.min(24, Math.floor((i - 1) / 3) * 3));
  }
  return d3_formatPrefixes[8 + i / 3];
};
function d3_formatPrefix(d, i) {
  var k = Math.pow(10, abs(8 - i) * 3);
  return {
    scale: i > 8 ? function(d) {
      return d / k;
    } : function(d) {
      return d * k;
    },
    symbol: d
  };
}
function d3_locale_numberFormat(locale) {
  var locale_decimal = locale.decimal, locale_thousands = locale.thousands, locale_grouping = locale.grouping, locale_currency = locale.currency, formatGroup = locale_grouping && locale_thousands ? function(value, width) {
    var i = value.length, t = [], j = 0, g = locale_grouping[0], length = 0;
    while (i > 0 && g > 0) {
      if (length + g + 1 > width) g = Math.max(1, width - length);
      t.push(value.substring(i -= g, i + g));
      if ((length += g + 1) > width) break;
      g = locale_grouping[j = (j + 1) % locale_grouping.length];
    }
    return t.reverse().join(locale_thousands);
  } : d3_identity;
  return function(specifier) {
    var match = d3_format_re.exec(specifier), fill = match[1] || " ", align = match[2] || ">", sign = match[3] || "-", symbol = match[4] || "", zfill = match[5], width = +match[6], comma = match[7], precision = match[8], type = match[9], scale = 1, prefix = "", suffix = "", integer = false, exponent = true;
    if (precision) precision = +precision.substring(1);
    if (zfill || fill === "0" && align === "=") {
      zfill = fill = "0";
      align = "=";
    }
    switch (type) {
     case "n":
      comma = true;
      type = "g";
      break;

     case "%":
      scale = 100;
      suffix = "%";
      type = "f";
      break;

     case "p":
      scale = 100;
      suffix = "%";
      type = "r";
      break;

     case "b":
     case "o":
     case "x":
     case "X":
      if (symbol === "#") prefix = "0" + type.toLowerCase();

     case "c":
      exponent = false;

     case "d":
      integer = true;
      precision = 0;
      break;

     case "s":
      scale = -1;
      type = "r";
      break;
    }
    if (symbol === "$") prefix = locale_currency[0], suffix = locale_currency[1];
    if (type == "r" && !precision) type = "g";
    if (precision != null) {
      if (type == "g") precision = Math.max(1, Math.min(21, precision)); else if (type == "e" || type == "f") precision = Math.max(0, Math.min(20, precision));
    }
    type = d3_format_types.get(type) || d3_format_typeDefault;
    var zcomma = zfill && comma;
    return function(value) {
      var fullSuffix = suffix;
      if (integer && value % 1) return "";
      var negative = value < 0 || value === 0 && 1 / value < 0 ? (value = -value, "-") : sign === "-" ? "" : sign;
      if (scale < 0) {
        var unit = d3.formatPrefix(value, precision);
        value = unit.scale(value);
        fullSuffix = unit.symbol + suffix;
      } else {
        value *= scale;
      }
      value = type(value, precision);
      var i = value.lastIndexOf("."), before, after;
      if (i < 0) {
        var j = exponent ? value.lastIndexOf("e") : -1;
        if (j < 0) before = value, after = ""; else before = value.substring(0, j), after = value.substring(j);
      } else {
        before = value.substring(0, i);
        after = locale_decimal + value.substring(i + 1);
      }
      if (!zfill && comma) before = formatGroup(before, Infinity);
      var length = prefix.length + before.length + after.length + (zcomma ? 0 : negative.length), padding = length < width ? new Array(length = width - length + 1).join(fill) : "";
      if (zcomma) before = formatGroup(padding + before, padding.length ? width - after.length : Infinity);
      negative += prefix;
      value = before + after;
      return (align === "<" ? negative + value + padding : align === ">" ? padding + negative + value : align === "^" ? padding.substring(0, length >>= 1) + negative + value + padding.substring(length) : negative + (zcomma ? value : padding + value)) + fullSuffix;
    };
  };
}
var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?([$#])?(0)?(\d+)?(,)?(\.-?\d+)?([a-z%])?/i;
var d3_format_types = d3.map({
  b: function(x) {
    return x.toString(2);
  },
  c: function(x) {
    return String.fromCharCode(x);
  },
  o: function(x) {
    return x.toString(8);
  },
  x: function(x) {
    return x.toString(16);
  },
  X: function(x) {
    return x.toString(16).toUpperCase();
  },
  g: function(x, p) {
    return x.toPrecision(p);
  },
  e: function(x, p) {
    return x.toExponential(p);
  },
  f: function(x, p) {
    return x.toFixed(p);
  },
  r: function(x, p) {
    return (x = d3.round(x, d3_format_precision(x, p))).toFixed(Math.max(0, Math.min(20, d3_format_precision(x * (1 + 1e-15), p))));
  }
});
function d3_format_typeDefault(x) {
  return x + "";
}
var d3_time = d3.time = {}, d3_date = Date;
function d3_date_utc() {
  this._ = new Date(arguments.length > 1 ? Date.UTC.apply(this, arguments) : arguments[0]);
}
d3_date_utc.prototype = {
  getDate: function() {
    return this._.getUTCDate();
  },
  getDay: function() {
    return this._.getUTCDay();
  },
  getFullYear: function() {
    return this._.getUTCFullYear();
  },
  getHours: function() {
    return this._.getUTCHours();
  },
  getMilliseconds: function() {
    return this._.getUTCMilliseconds();
  },
  getMinutes: function() {
    return this._.getUTCMinutes();
  },
  getMonth: function() {
    return this._.getUTCMonth();
  },
  getSeconds: function() {
    return this._.getUTCSeconds();
  },
  getTime: function() {
    return this._.getTime();
  },
  getTimezoneOffset: function() {
    return 0;
  },
  valueOf: function() {
    return this._.valueOf();
  },
  setDate: function() {
    d3_time_prototype.setUTCDate.apply(this._, arguments);
  },
  setDay: function() {
    d3_time_prototype.setUTCDay.apply(this._, arguments);
  },
  setFullYear: function() {
    d3_time_prototype.setUTCFullYear.apply(this._, arguments);
  },
  setHours: function() {
    d3_time_prototype.setUTCHours.apply(this._, arguments);
  },
  setMilliseconds: function() {
    d3_time_prototype.setUTCMilliseconds.apply(this._, arguments);
  },
  setMinutes: function() {
    d3_time_prototype.setUTCMinutes.apply(this._, arguments);
  },
  setMonth: function() {
    d3_time_prototype.setUTCMonth.apply(this._, arguments);
  },
  setSeconds: function() {
    d3_time_prototype.setUTCSeconds.apply(this._, arguments);
  },
  setTime: function() {
    d3_time_prototype.setTime.apply(this._, arguments);
  }
};
var d3_time_prototype = Date.prototype;
function d3_time_interval(local, step, number) {
  function round(date) {
    var d0 = local(date), d1 = offset(d0, 1);
    return date - d0 < d1 - date ? d0 : d1;
  }
  function ceil(date) {
    step(date = local(new d3_date(date - 1)), 1);
    return date;
  }
  function offset(date, k) {
    step(date = new d3_date(+date), k);
    return date;
  }
  function range(t0, t1, dt) {
    var time = ceil(t0), times = [];
    if (dt > 1) {
      while (time < t1) {
        if (!(number(time) % dt)) times.push(new Date(+time));
        step(time, 1);
      }
    } else {
      while (time < t1) times.push(new Date(+time)), step(time, 1);
    }
    return times;
  }
  function range_utc(t0, t1, dt) {
    try {
      d3_date = d3_date_utc;
      var utc = new d3_date_utc();
      utc._ = t0;
      return range(utc, t1, dt);
    } finally {
      d3_date = Date;
    }
  }
  local.floor = local;
  local.round = round;
  local.ceil = ceil;
  local.offset = offset;
  local.range = range;
  var utc = local.utc = d3_time_interval_utc(local);
  utc.floor = utc;
  utc.round = d3_time_interval_utc(round);
  utc.ceil = d3_time_interval_utc(ceil);
  utc.offset = d3_time_interval_utc(offset);
  utc.range = range_utc;
  return local;
}
function d3_time_interval_utc(method) {
  return function(date, k) {
    try {
      d3_date = d3_date_utc;
      var utc = new d3_date_utc();
      utc._ = date;
      return method(utc, k)._;
    } finally {
      d3_date = Date;
    }
  };
}
d3_time.year = d3_time_interval(function(date) {
  date = d3_time.day(date);
  date.setMonth(0, 1);
  return date;
}, function(date, offset) {
  date.setFullYear(date.getFullYear() + offset);
}, function(date) {
  return date.getFullYear();
});
d3_time.years = d3_time.year.range;
d3_time.years.utc = d3_time.year.utc.range;
d3_time.day = d3_time_interval(function(date) {
  var day = new d3_date(2e3, 0);
  day.setFullYear(date.getFullYear(), date.getMonth(), date.getDate());
  return day;
}, function(date, offset) {
  date.setDate(date.getDate() + offset);
}, function(date) {
  return date.getDate() - 1;
});
d3_time.days = d3_time.day.range;
d3_time.days.utc = d3_time.day.utc.range;
d3_time.dayOfYear = function(date) {
  var year = d3_time.year(date);
  return Math.floor((date - year - (date.getTimezoneOffset() - year.getTimezoneOffset()) * 6e4) / 864e5);
};
[ "sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday" ].forEach(function(day, i) {
  i = 7 - i;
  var interval = d3_time[day] = d3_time_interval(function(date) {
    (date = d3_time.day(date)).setDate(date.getDate() - (date.getDay() + i) % 7);
    return date;
  }, function(date, offset) {
    date.setDate(date.getDate() + Math.floor(offset) * 7);
  }, function(date) {
    var day = d3_time.year(date).getDay();
    return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7) - (day !== i);
  });
  d3_time[day + "s"] = interval.range;
  d3_time[day + "s"].utc = interval.utc.range;
  d3_time[day + "OfYear"] = function(date) {
    var day = d3_time.year(date).getDay();
    return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7);
  };
});
d3_time.week = d3_time.sunday;
d3_time.weeks = d3_time.sunday.range;
d3_time.weeks.utc = d3_time.sunday.utc.range;
d3_time.weekOfYear = d3_time.sundayOfYear;
function d3_locale_timeFormat(locale) {
  var locale_dateTime = locale.dateTime, locale_date = locale.date, locale_time = locale.time, locale_periods = locale.periods, locale_days = locale.days, locale_shortDays = locale.shortDays, locale_months = locale.months, locale_shortMonths = locale.shortMonths;
  function d3_time_format(template) {
    var n = template.length;
    function format(date) {
      var string = [], i = -1, j = 0, c, p, f;
      while (++i < n) {
        if (template.charCodeAt(i) === 37) {
          string.push(template.slice(j, i));
          if ((p = d3_time_formatPads[c = template.charAt(++i)]) != null) c = template.charAt(++i);
          if (f = d3_time_formats[c]) c = f(date, p == null ? c === "e" ? " " : "0" : p);
          string.push(c);
          j = i + 1;
        }
      }
      string.push(template.slice(j, i));
      return string.join("");
    }
    format.parse = function(string) {
      var d = {
        y: 1900,
        m: 0,
        d: 1,
        H: 0,
        M: 0,
        S: 0,
        L: 0,
        Z: null
      }, i = d3_time_parse(d, template, string, 0);
      if (i != string.length) return null;
      if ("p" in d) d.H = d.H % 12 + d.p * 12;
      var localZ = d.Z != null && d3_date !== d3_date_utc, date = new (localZ ? d3_date_utc : d3_date)();
      if ("j" in d) date.setFullYear(d.y, 0, d.j); else if ("W" in d || "U" in d) {
        if (!("w" in d)) d.w = "W" in d ? 1 : 0;
        date.setFullYear(d.y, 0, 1);
        date.setFullYear(d.y, 0, "W" in d ? (d.w + 6) % 7 + d.W * 7 - (date.getDay() + 5) % 7 : d.w + d.U * 7 - (date.getDay() + 6) % 7);
      } else date.setFullYear(d.y, d.m, d.d);
      date.setHours(d.H + (d.Z / 100 | 0), d.M + d.Z % 100, d.S, d.L);
      return localZ ? date._ : date;
    };
    format.toString = function() {
      return template;
    };
    return format;
  }
  function d3_time_parse(date, template, string, j) {
    var c, p, t, i = 0, n = template.length, m = string.length;
    while (i < n) {
      if (j >= m) return -1;
      c = template.charCodeAt(i++);
      if (c === 37) {
        t = template.charAt(i++);
        p = d3_time_parsers[t in d3_time_formatPads ? template.charAt(i++) : t];
        if (!p || (j = p(date, string, j)) < 0) return -1;
      } else if (c != string.charCodeAt(j++)) {
        return -1;
      }
    }
    return j;
  }
  d3_time_format.utc = function(template) {
    var local = d3_time_format(template);
    function format(date) {
      try {
        d3_date = d3_date_utc;
        var utc = new d3_date();
        utc._ = date;
        return local(utc);
      } finally {
        d3_date = Date;
      }
    }
    format.parse = function(string) {
      try {
        d3_date = d3_date_utc;
        var date = local.parse(string);
        return date && date._;
      } finally {
        d3_date = Date;
      }
    };
    format.toString = local.toString;
    return format;
  };
  d3_time_format.multi = d3_time_format.utc.multi = d3_time_formatMulti;
  var d3_time_periodLookup = d3.map(), d3_time_dayRe = d3_time_formatRe(locale_days), d3_time_dayLookup = d3_time_formatLookup(locale_days), d3_time_dayAbbrevRe = d3_time_formatRe(locale_shortDays), d3_time_dayAbbrevLookup = d3_time_formatLookup(locale_shortDays), d3_time_monthRe = d3_time_formatRe(locale_months), d3_time_monthLookup = d3_time_formatLookup(locale_months), d3_time_monthAbbrevRe = d3_time_formatRe(locale_shortMonths), d3_time_monthAbbrevLookup = d3_time_formatLookup(locale_shortMonths);
  locale_periods.forEach(function(p, i) {
    d3_time_periodLookup.set(p.toLowerCase(), i);
  });
  var d3_time_formats = {
    a: function(d) {
      return locale_shortDays[d.getDay()];
    },
    A: function(d) {
      return locale_days[d.getDay()];
    },
    b: function(d) {
      return locale_shortMonths[d.getMonth()];
    },
    B: function(d) {
      return locale_months[d.getMonth()];
    },
    c: d3_time_format(locale_dateTime),
    d: function(d, p) {
      return d3_time_formatPad(d.getDate(), p, 2);
    },
    e: function(d, p) {
      return d3_time_formatPad(d.getDate(), p, 2);
    },
    H: function(d, p) {
      return d3_time_formatPad(d.getHours(), p, 2);
    },
    I: function(d, p) {
      return d3_time_formatPad(d.getHours() % 12 || 12, p, 2);
    },
    j: function(d, p) {
      return d3_time_formatPad(1 + d3_time.dayOfYear(d), p, 3);
    },
    L: function(d, p) {
      return d3_time_formatPad(d.getMilliseconds(), p, 3);
    },
    m: function(d, p) {
      return d3_time_formatPad(d.getMonth() + 1, p, 2);
    },
    M: function(d, p) {
      return d3_time_formatPad(d.getMinutes(), p, 2);
    },
    p: function(d) {
      return locale_periods[+(d.getHours() >= 12)];
    },
    S: function(d, p) {
      return d3_time_formatPad(d.getSeconds(), p, 2);
    },
    U: function(d, p) {
      return d3_time_formatPad(d3_time.sundayOfYear(d), p, 2);
    },
    w: function(d) {
      return d.getDay();
    },
    W: function(d, p) {
      return d3_time_formatPad(d3_time.mondayOfYear(d), p, 2);
    },
    x: d3_time_format(locale_date),
    X: d3_time_format(locale_time),
    y: function(d, p) {
      return d3_time_formatPad(d.getFullYear() % 100, p, 2);
    },
    Y: function(d, p) {
      return d3_time_formatPad(d.getFullYear() % 1e4, p, 4);
    },
    Z: d3_time_zone,
    "%": function() {
      return "%";
    }
  };
  var d3_time_parsers = {
    a: d3_time_parseWeekdayAbbrev,
    A: d3_time_parseWeekday,
    b: d3_time_parseMonthAbbrev,
    B: d3_time_parseMonth,
    c: d3_time_parseLocaleFull,
    d: d3_time_parseDay,
    e: d3_time_parseDay,
    H: d3_time_parseHour24,
    I: d3_time_parseHour24,
    j: d3_time_parseDayOfYear,
    L: d3_time_parseMilliseconds,
    m: d3_time_parseMonthNumber,
    M: d3_time_parseMinutes,
    p: d3_time_parseAmPm,
    S: d3_time_parseSeconds,
    U: d3_time_parseWeekNumberSunday,
    w: d3_time_parseWeekdayNumber,
    W: d3_time_parseWeekNumberMonday,
    x: d3_time_parseLocaleDate,
    X: d3_time_parseLocaleTime,
    y: d3_time_parseYear,
    Y: d3_time_parseFullYear,
    Z: d3_time_parseZone,
    "%": d3_time_parseLiteralPercent
  };
  function d3_time_parseWeekdayAbbrev(date, string, i) {
    d3_time_dayAbbrevRe.lastIndex = 0;
    var n = d3_time_dayAbbrevRe.exec(string.slice(i));
    return n ? (date.w = d3_time_dayAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
  }
  function d3_time_parseWeekday(date, string, i) {
    d3_time_dayRe.lastIndex = 0;
    var n = d3_time_dayRe.exec(string.slice(i));
    return n ? (date.w = d3_time_dayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
  }
  function d3_time_parseMonthAbbrev(date, string, i) {
    d3_time_monthAbbrevRe.lastIndex = 0;
    var n = d3_time_monthAbbrevRe.exec(string.slice(i));
    return n ? (date.m = d3_time_monthAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
  }
  function d3_time_parseMonth(date, string, i) {
    d3_time_monthRe.lastIndex = 0;
    var n = d3_time_monthRe.exec(string.slice(i));
    return n ? (date.m = d3_time_monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
  }
  function d3_time_parseLocaleFull(date, string, i) {
    return d3_time_parse(date, d3_time_formats.c.toString(), string, i);
  }
  function d3_time_parseLocaleDate(date, string, i) {
    return d3_time_parse(date, d3_time_formats.x.toString(), string, i);
  }
  function d3_time_parseLocaleTime(date, string, i) {
    return d3_time_parse(date, d3_time_formats.X.toString(), string, i);
  }
  function d3_time_parseAmPm(date, string, i) {
    var n = d3_time_periodLookup.get(string.slice(i, i += 2).toLowerCase());
    return n == null ? -1 : (date.p = n, i);
  }
  return d3_time_format;
}
var d3_time_formatPads = {
  "-": "",
  _: " ",
  "0": "0"
}, d3_time_numberRe = /^\s*\d+/, d3_time_percentRe = /^%/;
function d3_time_formatPad(value, fill, width) {
  var sign = value < 0 ? "-" : "", string = (sign ? -value : value) + "", length = string.length;
  return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);
}
function d3_time_formatRe(names) {
  return new RegExp("^(?:" + names.map(d3.requote).join("|") + ")", "i");
}
function d3_time_formatLookup(names) {
  var map = new d3_Map(), i = -1, n = names.length;
  while (++i < n) map.set(names[i].toLowerCase(), i);
  return map;
}
function d3_time_parseWeekdayNumber(date, string, i) {
  d3_time_numberRe.lastIndex = 0;
  var n = d3_time_numberRe.exec(string.slice(i, i + 1));
  return n ? (date.w = +n[0], i + n[0].length) : -1;
}
function d3_time_parseWeekNumberSunday(date, string, i) {
  d3_time_numberRe.lastIndex = 0;
  var n = d3_time_numberRe.exec(string.slice(i));
  return n ? (date.U = +n[0], i + n[0].length) : -1;
}
function d3_time_parseWeekNumberMonday(date, string, i) {
  d3_time_numberRe.lastIndex = 0;
  var n = d3_time_numberRe.exec(string.slice(i));
  return n ? (date.W = +n[0], i + n[0].length) : -1;
}
function d3_time_parseFullYear(date, string, i) {
  d3_time_numberRe.lastIndex = 0;
  var n = d3_time_numberRe.exec(string.slice(i, i + 4));
  return n ? (date.y = +n[0], i + n[0].length) : -1;
}
function d3_time_parseYear(date, string, i) {
  d3_time_numberRe.lastIndex = 0;
  var n = d3_time_numberRe.exec(string.slice(i, i + 2));
  return n ? (date.y = d3_time_expandYear(+n[0]), i + n[0].length) : -1;
}
function d3_time_parseZone(date, string, i) {
  return /^[+-]\d{4}$/.test(string = string.slice(i, i + 5)) ? (date.Z = -string, 
  i + 5) : -1;
}
function d3_time_expandYear(d) {
  return d + (d > 68 ? 1900 : 2e3);
}
function d3_time_parseMonthNumber(date, string, i) {
  d3_time_numberRe.lastIndex = 0;
  var n = d3_time_numberRe.exec(string.slice(i, i + 2));
  return n ? (date.m = n[0] - 1, i + n[0].length) : -1;
}
function d3_time_parseDay(date, string, i) {
  d3_time_numberRe.lastIndex = 0;
  var n = d3_time_numberRe.exec(string.slice(i, i + 2));
  return n ? (date.d = +n[0], i + n[0].length) : -1;
}
function d3_time_parseDayOfYear(date, string, i) {
  d3_time_numberRe.lastIndex = 0;
  var n = d3_time_numberRe.exec(string.slice(i, i + 3));
  return n ? (date.j = +n[0], i + n[0].length) : -1;
}
function d3_time_parseHour24(date, string, i) {
  d3_time_numberRe.lastIndex = 0;
  var n = d3_time_numberRe.exec(string.slice(i, i + 2));
  return n ? (date.H = +n[0], i + n[0].length) : -1;
}
function d3_time_parseMinutes(date, string, i) {
  d3_time_numberRe.lastIndex = 0;
  var n = d3_time_numberRe.exec(string.slice(i, i + 2));
  return n ? (date.M = +n[0], i + n[0].length) : -1;
}
function d3_time_parseSeconds(date, string, i) {
  d3_time_numberRe.lastIndex = 0;
  var n = d3_time_numberRe.exec(string.slice(i, i + 2));
  return n ? (date.S = +n[0], i + n[0].length) : -1;
}
function d3_time_parseMilliseconds(date, string, i) {
  d3_time_numberRe.lastIndex = 0;
  var n = d3_time_numberRe.exec(string.slice(i, i + 3));
  return n ? (date.L = +n[0], i + n[0].length) : -1;
}
function d3_time_zone(d) {
  var z = d.getTimezoneOffset(), zs = z > 0 ? "-" : "+", zh = abs(z) / 60 | 0, zm = abs(z) % 60;
  return zs + d3_time_formatPad(zh, "0", 2) + d3_time_formatPad(zm, "0", 2);
}
function d3_time_parseLiteralPercent(date, string, i) {
  d3_time_percentRe.lastIndex = 0;
  var n = d3_time_percentRe.exec(string.slice(i, i + 1));
  return n ? i + n[0].length : -1;
}
function d3_time_formatMulti(formats) {
  var n = formats.length, i = -1;
  while (++i < n) formats[i][0] = this(formats[i][0]);
  return function(date) {
    var i = 0, f = formats[i];
    while (!f[1](date)) f = formats[++i];
    return f[0](date);
  };
}
d3.locale = function(locale) {
  return {
    numberFormat: d3_locale_numberFormat(locale),
    timeFormat: d3_locale_timeFormat(locale)
  };
};
var d3_locale_enUS = d3.locale({
  decimal: ".",
  thousands: ",",
  grouping: [ 3 ],
  currency: [ "$", "" ],
  dateTime: "%a %b %e %X %Y",
  date: "%m/%d/%Y",
  time: "%H:%M:%S",
  periods: [ "AM", "PM" ],
  days: [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ],
  shortDays: [ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" ],
  months: [ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ],
  shortMonths: [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ]
});
d3.format = d3_locale_enUS.numberFormat;
d3.geo = {};
function d3_adder() {}
d3_adder.prototype = {
  s: 0,
  t: 0,
  add: function(y) {
    d3_adderSum(y, this.t, d3_adderTemp);
    d3_adderSum(d3_adderTemp.s, this.s, this);
    if (this.s) this.t += d3_adderTemp.t; else this.s = d3_adderTemp.t;
  },
  reset: function() {
    this.s = this.t = 0;
  },
  valueOf: function() {
    return this.s;
  }
};
var d3_adderTemp = new d3_adder();
function d3_adderSum(a, b, o) {
  var x = o.s = a + b, bv = x - a, av = x - bv;
  o.t = a - av + (b - bv);
}
d3.geo.stream = function(object, listener) {
  if (object && d3_geo_streamObjectType.hasOwnProperty(object.type)) {
    d3_geo_streamObjectType[object.type](object, listener);
  } else {
    d3_geo_streamGeometry(object, listener);
  }
};
function d3_geo_streamGeometry(geometry, listener) {
  if (geometry && d3_geo_streamGeometryType.hasOwnProperty(geometry.type)) {
    d3_geo_streamGeometryType[geometry.type](geometry, listener);
  }
}
var d3_geo_streamObjectType = {
  Feature: function(feature, listener) {
    d3_geo_streamGeometry(feature.geometry, listener);
  },
  FeatureCollection: function(object, listener) {
    var features = object.features, i = -1, n = features.length;
    while (++i < n) d3_geo_streamGeometry(features[i].geometry, listener);
  }
};
var d3_geo_streamGeometryType = {
  Sphere: function(object, listener) {
    listener.sphere();
  },
  Point: function(object, listener) {
    object = object.coordinates;
    listener.point(object[0], object[1], object[2]);
  },
  MultiPoint: function(object, listener) {
    var coordinates = object.coordinates, i = -1, n = coordinates.length;
    while (++i < n) object = coordinates[i], listener.point(object[0], object[1], object[2]);
  },
  LineString: function(object, listener) {
    d3_geo_streamLine(object.coordinates, listener, 0);
  },
  MultiLineString: function(object, listener) {
    var coordinates = object.coordinates, i = -1, n = coordinates.length;
    while (++i < n) d3_geo_streamLine(coordinates[i], listener, 0);
  },
  Polygon: function(object, listener) {
    d3_geo_streamPolygon(object.coordinates, listener);
  },
  MultiPolygon: function(object, listener) {
    var coordinates = object.coordinates, i = -1, n = coordinates.length;
    while (++i < n) d3_geo_streamPolygon(coordinates[i], listener);
  },
  GeometryCollection: function(object, listener) {
    var geometries = object.geometries, i = -1, n = geometries.length;
    while (++i < n) d3_geo_streamGeometry(geometries[i], listener);
  }
};
function d3_geo_streamLine(coordinates, listener, closed) {
  var i = -1, n = coordinates.length - closed, coordinate;
  listener.lineStart();
  while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1], coordinate[2]);
  listener.lineEnd();
}
function d3_geo_streamPolygon(coordinates, listener) {
  var i = -1, n = coordinates.length;
  listener.polygonStart();
  while (++i < n) d3_geo_streamLine(coordinates[i], listener, 1);
  listener.polygonEnd();
}
d3.geo.area = function(object) {
  d3_geo_areaSum = 0;
  d3.geo.stream(object, d3_geo_area);
  return d3_geo_areaSum;
};
var d3_geo_areaSum, d3_geo_areaRingSum = new d3_adder();
var d3_geo_area = {
  sphere: function() {
    d3_geo_areaSum += 4 * π;
  },
  point: d3_noop,
  lineStart: d3_noop,
  lineEnd: d3_noop,
  polygonStart: function() {
    d3_geo_areaRingSum.reset();
    d3_geo_area.lineStart = d3_geo_areaRingStart;
  },
  polygonEnd: function() {
    var area = 2 * d3_geo_areaRingSum;
    d3_geo_areaSum += area < 0 ? 4 * π + area : area;
    d3_geo_area.lineStart = d3_geo_area.lineEnd = d3_geo_area.point = d3_noop;
  }
};
function d3_geo_areaRingStart() {
  var λ00, φ00, λ0, cosφ0, sinφ0;
  d3_geo_area.point = function(λ, φ) {
    d3_geo_area.point = nextPoint;
    λ0 = (λ00 = λ) * d3_radians, cosφ0 = Math.cos(φ = (φ00 = φ) * d3_radians / 2 + π / 4), 
    sinφ0 = Math.sin(φ);
  };
  function nextPoint(λ, φ) {
    λ *= d3_radians;
    φ = φ * d3_radians / 2 + π / 4;
    var dλ = λ - λ0, sdλ = dλ >= 0 ? 1 : -1, adλ = sdλ * dλ, cosφ = Math.cos(φ), sinφ = Math.sin(φ), k = sinφ0 * sinφ, u = cosφ0 * cosφ + k * Math.cos(adλ), v = k * sdλ * Math.sin(adλ);
    d3_geo_areaRingSum.add(Math.atan2(v, u));
    λ0 = λ, cosφ0 = cosφ, sinφ0 = sinφ;
  }
  d3_geo_area.lineEnd = function() {
    nextPoint(λ00, φ00);
  };
}
function d3_geo_cartesian(spherical) {
  var λ = spherical[0], φ = spherical[1], cosφ = Math.cos(φ);
  return [ cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ) ];
}
function d3_geo_cartesianDot(a, b) {
  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}
function d3_geo_cartesianCross(a, b) {
  return [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0] ];
}
function d3_geo_cartesianAdd(a, b) {
  a[0] += b[0];
  a[1] += b[1];
  a[2] += b[2];
}
function d3_geo_cartesianScale(vector, k) {
  return [ vector[0] * k, vector[1] * k, vector[2] * k ];
}
function d3_geo_cartesianNormalize(d) {
  var l = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
  d[0] /= l;
  d[1] /= l;
  d[2] /= l;
}
function d3_geo_spherical(cartesian) {
  return [ Math.atan2(cartesian[1], cartesian[0]), d3_asin(cartesian[2]) ];
}
function d3_geo_sphericalEqual(a, b) {
  return abs(a[0] - b[0]) < ε && abs(a[1] - b[1]) < ε;
}
d3.geo.bounds = function() {
  var λ0, φ0, λ1, φ1, λ_, λ__, φ__, p0, dλSum, ranges, range;
  var bound = {
    point: point,
    lineStart: lineStart,
    lineEnd: lineEnd,
    polygonStart: function() {
      bound.point = ringPoint;
      bound.lineStart = ringStart;
      bound.lineEnd = ringEnd;
      dλSum = 0;
      d3_geo_area.polygonStart();
    },
    polygonEnd: function() {
      d3_geo_area.polygonEnd();
      bound.point = point;
      bound.lineStart = lineStart;
      bound.lineEnd = lineEnd;
      if (d3_geo_areaRingSum < 0) λ0 = -(λ1 = 180), φ0 = -(φ1 = 90); else if (dλSum > ε) φ1 = 90; else if (dλSum < -ε) φ0 = -90;
      range[0] = λ0, range[1] = λ1;
    }
  };
  function point(λ, φ) {
    ranges.push(range = [ λ0 = λ, λ1 = λ ]);
    if (φ < φ0) φ0 = φ;
    if (φ > φ1) φ1 = φ;
  }
  function linePoint(λ, φ) {
    var p = d3_geo_cartesian([ λ * d3_radians, φ * d3_radians ]);
    if (p0) {
      var normal = d3_geo_cartesianCross(p0, p), equatorial = [ normal[1], -normal[0], 0 ], inflection = d3_geo_cartesianCross(equatorial, normal);
      d3_geo_cartesianNormalize(inflection);
      inflection = d3_geo_spherical(inflection);
      var dλ = λ - λ_, s = dλ > 0 ? 1 : -1, λi = inflection[0] * d3_degrees * s, antimeridian = abs(dλ) > 180;
      if (antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
        var φi = inflection[1] * d3_degrees;
        if (φi > φ1) φ1 = φi;
      } else if (λi = (λi + 360) % 360 - 180, antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
        var φi = -inflection[1] * d3_degrees;
        if (φi < φ0) φ0 = φi;
      } else {
        if (φ < φ0) φ0 = φ;
        if (φ > φ1) φ1 = φ;
      }
      if (antimeridian) {
        if (λ < λ_) {
          if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
        } else {
          if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
        }
      } else {
        if (λ1 >= λ0) {
          if (λ < λ0) λ0 = λ;
          if (λ > λ1) λ1 = λ;
        } else {
          if (λ > λ_) {
            if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
          } else {
            if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
          }
        }
      }
    } else {
      point(λ, φ);
    }
    p0 = p, λ_ = λ;
  }
  function lineStart() {
    bound.point = linePoint;
  }
  function lineEnd() {
    range[0] = λ0, range[1] = λ1;
    bound.point = point;
    p0 = null;
  }
  function ringPoint(λ, φ) {
    if (p0) {
      var dλ = λ - λ_;
      dλSum += abs(dλ) > 180 ? dλ + (dλ > 0 ? 360 : -360) : dλ;
    } else λ__ = λ, φ__ = φ;
    d3_geo_area.point(λ, φ);
    linePoint(λ, φ);
  }
  function ringStart() {
    d3_geo_area.lineStart();
  }
  function ringEnd() {
    ringPoint(λ__, φ__);
    d3_geo_area.lineEnd();
    if (abs(dλSum) > ε) λ0 = -(λ1 = 180);
    range[0] = λ0, range[1] = λ1;
    p0 = null;
  }
  function angle(λ0, λ1) {
    return (λ1 -= λ0) < 0 ? λ1 + 360 : λ1;
  }
  function compareRanges(a, b) {
    return a[0] - b[0];
  }
  function withinRange(x, range) {
    return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;
  }
  return function(feature) {
    φ1 = λ1 = -(λ0 = φ0 = Infinity);
    ranges = [];
    d3.geo.stream(feature, bound);
    var n = ranges.length;
    if (n) {
      ranges.sort(compareRanges);
      for (var i = 1, a = ranges[0], b, merged = [ a ]; i < n; ++i) {
        b = ranges[i];
        if (withinRange(b[0], a) || withinRange(b[1], a)) {
          if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];
          if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];
        } else {
          merged.push(a = b);
        }
      }
      var best = -Infinity, dλ;
      for (var n = merged.length - 1, i = 0, a = merged[n], b; i <= n; a = b, ++i) {
        b = merged[i];
        if ((dλ = angle(a[1], b[0])) > best) best = dλ, λ0 = b[0], λ1 = a[1];
      }
    }
    ranges = range = null;
    return λ0 === Infinity || φ0 === Infinity ? [ [ NaN, NaN ], [ NaN, NaN ] ] : [ [ λ0, φ0 ], [ λ1, φ1 ] ];
  };
}();
d3.geo.centroid = function(object) {
  d3_geo_centroidW0 = d3_geo_centroidW1 = d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 = d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 = d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0;
  d3.geo.stream(object, d3_geo_centroid);
  var x = d3_geo_centroidX2, y = d3_geo_centroidY2, z = d3_geo_centroidZ2, m = x * x + y * y + z * z;
  if (m < ε2) {
    x = d3_geo_centroidX1, y = d3_geo_centroidY1, z = d3_geo_centroidZ1;
    if (d3_geo_centroidW1 < ε) x = d3_geo_centroidX0, y = d3_geo_centroidY0, z = d3_geo_centroidZ0;
    m = x * x + y * y + z * z;
    if (m < ε2) return [ NaN, NaN ];
  }
  return [ Math.atan2(y, x) * d3_degrees, d3_asin(z / Math.sqrt(m)) * d3_degrees ];
};
var d3_geo_centroidW0, d3_geo_centroidW1, d3_geo_centroidX0, d3_geo_centroidY0, d3_geo_centroidZ0, d3_geo_centroidX1, d3_geo_centroidY1, d3_geo_centroidZ1, d3_geo_centroidX2, d3_geo_centroidY2, d3_geo_centroidZ2;
var d3_geo_centroid = {
  sphere: d3_noop,
  point: d3_geo_centroidPoint,
  lineStart: d3_geo_centroidLineStart,
  lineEnd: d3_geo_centroidLineEnd,
  polygonStart: function() {
    d3_geo_centroid.lineStart = d3_geo_centroidRingStart;
  },
  polygonEnd: function() {
    d3_geo_centroid.lineStart = d3_geo_centroidLineStart;
  }
};
function d3_geo_centroidPoint(λ, φ) {
  λ *= d3_radians;
  var cosφ = Math.cos(φ *= d3_radians);
  d3_geo_centroidPointXYZ(cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ));
}
function d3_geo_centroidPointXYZ(x, y, z) {
  ++d3_geo_centroidW0;
  d3_geo_centroidX0 += (x - d3_geo_centroidX0) / d3_geo_centroidW0;
  d3_geo_centroidY0 += (y - d3_geo_centroidY0) / d3_geo_centroidW0;
  d3_geo_centroidZ0 += (z - d3_geo_centroidZ0) / d3_geo_centroidW0;
}
function d3_geo_centroidLineStart() {
  var x0, y0, z0;
  d3_geo_centroid.point = function(λ, φ) {
    λ *= d3_radians;
    var cosφ = Math.cos(φ *= d3_radians);
    x0 = cosφ * Math.cos(λ);
    y0 = cosφ * Math.sin(λ);
    z0 = Math.sin(φ);
    d3_geo_centroid.point = nextPoint;
    d3_geo_centroidPointXYZ(x0, y0, z0);
  };
  function nextPoint(λ, φ) {
    λ *= d3_radians;
    var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), w = Math.atan2(Math.sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);
    d3_geo_centroidW1 += w;
    d3_geo_centroidX1 += w * (x0 + (x0 = x));
    d3_geo_centroidY1 += w * (y0 + (y0 = y));
    d3_geo_centroidZ1 += w * (z0 + (z0 = z));
    d3_geo_centroidPointXYZ(x0, y0, z0);
  }
}
function d3_geo_centroidLineEnd() {
  d3_geo_centroid.point = d3_geo_centroidPoint;
}
function d3_geo_centroidRingStart() {
  var λ00, φ00, x0, y0, z0;
  d3_geo_centroid.point = function(λ, φ) {
    λ00 = λ, φ00 = φ;
    d3_geo_centroid.point = nextPoint;
    λ *= d3_radians;
    var cosφ = Math.cos(φ *= d3_radians);
    x0 = cosφ * Math.cos(λ);
    y0 = cosφ * Math.sin(λ);
    z0 = Math.sin(φ);
    d3_geo_centroidPointXYZ(x0, y0, z0);
  };
  d3_geo_centroid.lineEnd = function() {
    nextPoint(λ00, φ00);
    d3_geo_centroid.lineEnd = d3_geo_centroidLineEnd;
    d3_geo_centroid.point = d3_geo_centroidPoint;
  };
  function nextPoint(λ, φ) {
    λ *= d3_radians;
    var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), cx = y0 * z - z0 * y, cy = z0 * x - x0 * z, cz = x0 * y - y0 * x, m = Math.sqrt(cx * cx + cy * cy + cz * cz), u = x0 * x + y0 * y + z0 * z, v = m && -d3_acos(u) / m, w = Math.atan2(m, u);
    d3_geo_centroidX2 += v * cx;
    d3_geo_centroidY2 += v * cy;
    d3_geo_centroidZ2 += v * cz;
    d3_geo_centroidW1 += w;
    d3_geo_centroidX1 += w * (x0 + (x0 = x));
    d3_geo_centroidY1 += w * (y0 + (y0 = y));
    d3_geo_centroidZ1 += w * (z0 + (z0 = z));
    d3_geo_centroidPointXYZ(x0, y0, z0);
  }
}
function d3_geo_compose(a, b) {
  function compose(x, y) {
    return x = a(x, y), b(x[0], x[1]);
  }
  if (a.invert && b.invert) compose.invert = function(x, y) {
    return x = b.invert(x, y), x && a.invert(x[0], x[1]);
  };
  return compose;
}
function d3_true() {
  return true;
}
function d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener) {
  var subject = [], clip = [];
  segments.forEach(function(segment) {
    if ((n = segment.length - 1) <= 0) return;
    var n, p0 = segment[0], p1 = segment[n];
    if (d3_geo_sphericalEqual(p0, p1)) {
      listener.lineStart();
      for (var i = 0; i < n; ++i) listener.point((p0 = segment[i])[0], p0[1]);
      listener.lineEnd();
      return;
    }
    var a = new d3_geo_clipPolygonIntersection(p0, segment, null, true), b = new d3_geo_clipPolygonIntersection(p0, null, a, false);
    a.o = b;
    subject.push(a);
    clip.push(b);
    a = new d3_geo_clipPolygonIntersection(p1, segment, null, false);
    b = new d3_geo_clipPolygonIntersection(p1, null, a, true);
    a.o = b;
    subject.push(a);
    clip.push(b);
  });
  clip.sort(compare);
  d3_geo_clipPolygonLinkCircular(subject);
  d3_geo_clipPolygonLinkCircular(clip);
  if (!subject.length) return;
  for (var i = 0, entry = clipStartInside, n = clip.length; i < n; ++i) {
    clip[i].e = entry = !entry;
  }
  var start = subject[0], points, point;
  while (1) {
    var current = start, isSubject = true;
    while (current.v) if ((current = current.n) === start) return;
    points = current.z;
    listener.lineStart();
    do {
      current.v = current.o.v = true;
      if (current.e) {
        if (isSubject) {
          for (var i = 0, n = points.length; i < n; ++i) listener.point((point = points[i])[0], point[1]);
        } else {
          interpolate(current.x, current.n.x, 1, listener);
        }
        current = current.n;
      } else {
        if (isSubject) {
          points = current.p.z;
          for (var i = points.length - 1; i >= 0; --i) listener.point((point = points[i])[0], point[1]);
        } else {
          interpolate(current.x, current.p.x, -1, listener);
        }
        current = current.p;
      }
      current = current.o;
      points = current.z;
      isSubject = !isSubject;
    } while (!current.v);
    listener.lineEnd();
  }
}
function d3_geo_clipPolygonLinkCircular(array) {
  if (!(n = array.length)) return;
  var n, i = 0, a = array[0], b;
  while (++i < n) {
    a.n = b = array[i];
    b.p = a;
    a = b;
  }
  a.n = b = array[0];
  b.p = a;
}
function d3_geo_clipPolygonIntersection(point, points, other, entry) {
  this.x = point;
  this.z = points;
  this.o = other;
  this.e = entry;
  this.v = false;
  this.n = this.p = null;
}
function d3_geo_clip(pointVisible, clipLine, interpolate, clipStart) {
  return function(rotate, listener) {
    var line = clipLine(listener), rotatedClipStart = rotate.invert(clipStart[0], clipStart[1]);
    var clip = {
      point: point,
      lineStart: lineStart,
      lineEnd: lineEnd,
      polygonStart: function() {
        clip.point = pointRing;
        clip.lineStart = ringStart;
        clip.lineEnd = ringEnd;
        segments = [];
        polygon = [];
      },
      polygonEnd: function() {
        clip.point = point;
        clip.lineStart = lineStart;
        clip.lineEnd = lineEnd;
        segments = d3.merge(segments);
        var clipStartInside = d3_geo_pointInPolygon(rotatedClipStart, polygon);
        if (segments.length) {
          if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
          d3_geo_clipPolygon(segments, d3_geo_clipSort, clipStartInside, interpolate, listener);
        } else if (clipStartInside) {
          if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
          listener.lineStart();
          interpolate(null, null, 1, listener);
          listener.lineEnd();
        }
        if (polygonStarted) listener.polygonEnd(), polygonStarted = false;
        segments = polygon = null;
      },
      sphere: function() {
        listener.polygonStart();
        listener.lineStart();
        interpolate(null, null, 1, listener);
        listener.lineEnd();
        listener.polygonEnd();
      }
    };
    function point(λ, φ) {
      var point = rotate(λ, φ);
      if (pointVisible(λ = point[0], φ = point[1])) listener.point(λ, φ);
    }
    function pointLine(λ, φ) {
      var point = rotate(λ, φ);
      line.point(point[0], point[1]);
    }
    function lineStart() {
      clip.point = pointLine;
      line.lineStart();
    }
    function lineEnd() {
      clip.point = point;
      line.lineEnd();
    }
    var segments;
    var buffer = d3_geo_clipBufferListener(), ringListener = clipLine(buffer), polygonStarted = false, polygon, ring;
    function pointRing(λ, φ) {
      ring.push([ λ, φ ]);
      var point = rotate(λ, φ);
      ringListener.point(point[0], point[1]);
    }
    function ringStart() {
      ringListener.lineStart();
      ring = [];
    }
    function ringEnd() {
      pointRing(ring[0][0], ring[0][1]);
      ringListener.lineEnd();
      var clean = ringListener.clean(), ringSegments = buffer.buffer(), segment, n = ringSegments.length;
      ring.pop();
      polygon.push(ring);
      ring = null;
      if (!n) return;
      if (clean & 1) {
        segment = ringSegments[0];
        var n = segment.length - 1, i = -1, point;
        if (n > 0) {
          if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
          listener.lineStart();
          while (++i < n) listener.point((point = segment[i])[0], point[1]);
          listener.lineEnd();
        }
        return;
      }
      if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
      segments.push(ringSegments.filter(d3_geo_clipSegmentLength1));
    }
    return clip;
  };
}
function d3_geo_clipSegmentLength1(segment) {
  return segment.length > 1;
}
function d3_geo_clipBufferListener() {
  var lines = [], line;
  return {
    lineStart: function() {
      lines.push(line = []);
    },
    point: function(λ, φ) {
      line.push([ λ, φ ]);
    },
    lineEnd: d3_noop,
    buffer: function() {
      var buffer = lines;
      lines = [];
      line = null;
      return buffer;
    },
    rejoin: function() {
      if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));
    }
  };
}
function d3_geo_clipSort(a, b) {
  return ((a = a.x)[0] < 0 ? a[1] - halfπ - ε : halfπ - a[1]) - ((b = b.x)[0] < 0 ? b[1] - halfπ - ε : halfπ - b[1]);
}
var d3_geo_clipAntimeridian = d3_geo_clip(d3_true, d3_geo_clipAntimeridianLine, d3_geo_clipAntimeridianInterpolate, [ -π, -π / 2 ]);
function d3_geo_clipAntimeridianLine(listener) {
  var λ0 = NaN, φ0 = NaN, sλ0 = NaN, clean;
  return {
    lineStart: function() {
      listener.lineStart();
      clean = 1;
    },
    point: function(λ1, φ1) {
      var sλ1 = λ1 > 0 ? π : -π, dλ = abs(λ1 - λ0);
      if (abs(dλ - π) < ε) {
        listener.point(λ0, φ0 = (φ0 + φ1) / 2 > 0 ? halfπ : -halfπ);
        listener.point(sλ0, φ0);
        listener.lineEnd();
        listener.lineStart();
        listener.point(sλ1, φ0);
        listener.point(λ1, φ0);
        clean = 0;
      } else if (sλ0 !== sλ1 && dλ >= π) {
        if (abs(λ0 - sλ0) < ε) λ0 -= sλ0 * ε;
        if (abs(λ1 - sλ1) < ε) λ1 -= sλ1 * ε;
        φ0 = d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1);
        listener.point(sλ0, φ0);
        listener.lineEnd();
        listener.lineStart();
        listener.point(sλ1, φ0);
        clean = 0;
      }
      listener.point(λ0 = λ1, φ0 = φ1);
      sλ0 = sλ1;
    },
    lineEnd: function() {
      listener.lineEnd();
      λ0 = φ0 = NaN;
    },
    clean: function() {
      return 2 - clean;
    }
  };
}
function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) {
  var cosφ0, cosφ1, sinλ0_λ1 = Math.sin(λ0 - λ1);
  return abs(sinλ0_λ1) > ε ? Math.atan((Math.sin(φ0) * (cosφ1 = Math.cos(φ1)) * Math.sin(λ1) - Math.sin(φ1) * (cosφ0 = Math.cos(φ0)) * Math.sin(λ0)) / (cosφ0 * cosφ1 * sinλ0_λ1)) : (φ0 + φ1) / 2;
}
function d3_geo_clipAntimeridianInterpolate(from, to, direction, listener) {
  var φ;
  if (from == null) {
    φ = direction * halfπ;
    listener.point(-π, φ);
    listener.point(0, φ);
    listener.point(π, φ);
    listener.point(π, 0);
    listener.point(π, -φ);
    listener.point(0, -φ);
    listener.point(-π, -φ);
    listener.point(-π, 0);
    listener.point(-π, φ);
  } else if (abs(from[0] - to[0]) > ε) {
    var s = from[0] < to[0] ? π : -π;
    φ = direction * s / 2;
    listener.point(-s, φ);
    listener.point(0, φ);
    listener.point(s, φ);
  } else {
    listener.point(to[0], to[1]);
  }
}
function d3_geo_pointInPolygon(point, polygon) {
  var meridian = point[0], parallel = point[1], meridianNormal = [ Math.sin(meridian), -Math.cos(meridian), 0 ], polarAngle = 0, winding = 0;
  d3_geo_areaRingSum.reset();
  for (var i = 0, n = polygon.length; i < n; ++i) {
    var ring = polygon[i], m = ring.length;
    if (!m) continue;
    var point0 = ring[0], λ0 = point0[0], φ0 = point0[1] / 2 + π / 4, sinφ0 = Math.sin(φ0), cosφ0 = Math.cos(φ0), j = 1;
    while (true) {
      if (j === m) j = 0;
      point = ring[j];
      var λ = point[0], φ = point[1] / 2 + π / 4, sinφ = Math.sin(φ), cosφ = Math.cos(φ), dλ = λ - λ0, sdλ = dλ >= 0 ? 1 : -1, adλ = sdλ * dλ, antimeridian = adλ > π, k = sinφ0 * sinφ;
      d3_geo_areaRingSum.add(Math.atan2(k * sdλ * Math.sin(adλ), cosφ0 * cosφ + k * Math.cos(adλ)));
      polarAngle += antimeridian ? dλ + sdλ * τ : dλ;
      if (antimeridian ^ λ0 >= meridian ^ λ >= meridian) {
        var arc = d3_geo_cartesianCross(d3_geo_cartesian(point0), d3_geo_cartesian(point));
        d3_geo_cartesianNormalize(arc);
        var intersection = d3_geo_cartesianCross(meridianNormal, arc);
        d3_geo_cartesianNormalize(intersection);
        var φarc = (antimeridian ^ dλ >= 0 ? -1 : 1) * d3_asin(intersection[2]);
        if (parallel > φarc || parallel === φarc && (arc[0] || arc[1])) {
          winding += antimeridian ^ dλ >= 0 ? 1 : -1;
        }
      }
      if (!j++) break;
      λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ, point0 = point;
    }
  }
  return (polarAngle < -ε || polarAngle < ε && d3_geo_areaRingSum < -ε) ^ winding & 1;
}
function d3_geo_clipCircle(radius) {
  var cr = Math.cos(radius), smallRadius = cr > 0, notHemisphere = abs(cr) > ε, interpolate = d3_geo_circleInterpolate(radius, 6 * d3_radians);
  return d3_geo_clip(visible, clipLine, interpolate, smallRadius ? [ 0, -radius ] : [ -π, radius - π ]);
  function visible(λ, φ) {
    return Math.cos(λ) * Math.cos(φ) > cr;
  }
  function clipLine(listener) {
    var point0, c0, v0, v00, clean;
    return {
      lineStart: function() {
        v00 = v0 = false;
        clean = 1;
      },
      point: function(λ, φ) {
        var point1 = [ λ, φ ], point2, v = visible(λ, φ), c = smallRadius ? v ? 0 : code(λ, φ) : v ? code(λ + (λ < 0 ? π : -π), φ) : 0;
        if (!point0 && (v00 = v0 = v)) listener.lineStart();
        if (v !== v0) {
          point2 = intersect(point0, point1);
          if (d3_geo_sphericalEqual(point0, point2) || d3_geo_sphericalEqual(point1, point2)) {
            point1[0] += ε;
            point1[1] += ε;
            v = visible(point1[0], point1[1]);
          }
        }
        if (v !== v0) {
          clean = 0;
          if (v) {
            listener.lineStart();
            point2 = intersect(point1, point0);
            listener.point(point2[0], point2[1]);
          } else {
            point2 = intersect(point0, point1);
            listener.point(point2[0], point2[1]);
            listener.lineEnd();
          }
          point0 = point2;
        } else if (notHemisphere && point0 && smallRadius ^ v) {
          var t;
          if (!(c & c0) && (t = intersect(point1, point0, true))) {
            clean = 0;
            if (smallRadius) {
              listener.lineStart();
              listener.point(t[0][0], t[0][1]);
              listener.point(t[1][0], t[1][1]);
              listener.lineEnd();
            } else {
              listener.point(t[1][0], t[1][1]);
              listener.lineEnd();
              listener.lineStart();
              listener.point(t[0][0], t[0][1]);
            }
          }
        }
        if (v && (!point0 || !d3_geo_sphericalEqual(point0, point1))) {
          listener.point(point1[0], point1[1]);
        }
        point0 = point1, v0 = v, c0 = c;
      },
      lineEnd: function() {
        if (v0) listener.lineEnd();
        point0 = null;
      },
      clean: function() {
        return clean | (v00 && v0) << 1;
      }
    };
  }
  function intersect(a, b, two) {
    var pa = d3_geo_cartesian(a), pb = d3_geo_cartesian(b);
    var n1 = [ 1, 0, 0 ], n2 = d3_geo_cartesianCross(pa, pb), n2n2 = d3_geo_cartesianDot(n2, n2), n1n2 = n2[0], determinant = n2n2 - n1n2 * n1n2;
    if (!determinant) return !two && a;
    var c1 = cr * n2n2 / determinant, c2 = -cr * n1n2 / determinant, n1xn2 = d3_geo_cartesianCross(n1, n2), A = d3_geo_cartesianScale(n1, c1), B = d3_geo_cartesianScale(n2, c2);
    d3_geo_cartesianAdd(A, B);
    var u = n1xn2, w = d3_geo_cartesianDot(A, u), uu = d3_geo_cartesianDot(u, u), t2 = w * w - uu * (d3_geo_cartesianDot(A, A) - 1);
    if (t2 < 0) return;
    var t = Math.sqrt(t2), q = d3_geo_cartesianScale(u, (-w - t) / uu);
    d3_geo_cartesianAdd(q, A);
    q = d3_geo_spherical(q);
    if (!two) return q;
    var λ0 = a[0], λ1 = b[0], φ0 = a[1], φ1 = b[1], z;
    if (λ1 < λ0) z = λ0, λ0 = λ1, λ1 = z;
    var δλ = λ1 - λ0, polar = abs(δλ - π) < ε, meridian = polar || δλ < ε;
    if (!polar && φ1 < φ0) z = φ0, φ0 = φ1, φ1 = z;
    if (meridian ? polar ? φ0 + φ1 > 0 ^ q[1] < (abs(q[0] - λ0) < ε ? φ0 : φ1) : φ0 <= q[1] && q[1] <= φ1 : δλ > π ^ (λ0 <= q[0] && q[0] <= λ1)) {
      var q1 = d3_geo_cartesianScale(u, (-w + t) / uu);
      d3_geo_cartesianAdd(q1, A);
      return [ q, d3_geo_spherical(q1) ];
    }
  }
  function code(λ, φ) {
    var r = smallRadius ? radius : π - radius, code = 0;
    if (λ < -r) code |= 1; else if (λ > r) code |= 2;
    if (φ < -r) code |= 4; else if (φ > r) code |= 8;
    return code;
  }
}
function d3_geom_clipLine(x0, y0, x1, y1) {
  return function(line) {
    var a = line.a, b = line.b, ax = a.x, ay = a.y, bx = b.x, by = b.y, t0 = 0, t1 = 1, dx = bx - ax, dy = by - ay, r;
    r = x0 - ax;
    if (!dx && r > 0) return;
    r /= dx;
    if (dx < 0) {
      if (r < t0) return;
      if (r < t1) t1 = r;
    } else if (dx > 0) {
      if (r > t1) return;
      if (r > t0) t0 = r;
    }
    r = x1 - ax;
    if (!dx && r < 0) return;
    r /= dx;
    if (dx < 0) {
      if (r > t1) return;
      if (r > t0) t0 = r;
    } else if (dx > 0) {
      if (r < t0) return;
      if (r < t1) t1 = r;
    }
    r = y0 - ay;
    if (!dy && r > 0) return;
    r /= dy;
    if (dy < 0) {
      if (r < t0) return;
      if (r < t1) t1 = r;
    } else if (dy > 0) {
      if (r > t1) return;
      if (r > t0) t0 = r;
    }
    r = y1 - ay;
    if (!dy && r < 0) return;
    r /= dy;
    if (dy < 0) {
      if (r > t1) return;
      if (r > t0) t0 = r;
    } else if (dy > 0) {
      if (r < t0) return;
      if (r < t1) t1 = r;
    }
    if (t0 > 0) line.a = {
      x: ax + t0 * dx,
      y: ay + t0 * dy
    };
    if (t1 < 1) line.b = {
      x: ax + t1 * dx,
      y: ay + t1 * dy
    };
    return line;
  };
}
var d3_geo_clipExtentMAX = 1e9;
d3.geo.clipExtent = function() {
  var x0, y0, x1, y1, stream, clip, clipExtent = {
    stream: function(output) {
      if (stream) stream.valid = false;
      stream = clip(output);
      stream.valid = true;
      return stream;
    },
    extent: function(_) {
      if (!arguments.length) return [ [ x0, y0 ], [ x1, y1 ] ];
      clip = d3_geo_clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]);
      if (stream) stream.valid = false, stream = null;
      return clipExtent;
    }
  };
  return clipExtent.extent([ [ 0, 0 ], [ 960, 500 ] ]);
};
function d3_geo_clipExtent(x0, y0, x1, y1) {
  return function(listener) {
    var listener_ = listener, bufferListener = d3_geo_clipBufferListener(), clipLine = d3_geom_clipLine(x0, y0, x1, y1), segments, polygon, ring;
    var clip = {
      point: point,
      lineStart: lineStart,
      lineEnd: lineEnd,
      polygonStart: function() {
        listener = bufferListener;
        segments = [];
        polygon = [];
        clean = true;
      },
      polygonEnd: function() {
        listener = listener_;
        segments = d3.merge(segments);
        var clipStartInside = insidePolygon([ x0, y1 ]), inside = clean && clipStartInside, visible = segments.length;
        if (inside || visible) {
          listener.polygonStart();
          if (inside) {
            listener.lineStart();
            interpolate(null, null, 1, listener);
            listener.lineEnd();
          }
          if (visible) {
            d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener);
          }
          listener.polygonEnd();
        }
        segments = polygon = ring = null;
      }
    };
    function insidePolygon(p) {
      var wn = 0, n = polygon.length, y = p[1];
      for (var i = 0; i < n; ++i) {
        for (var j = 1, v = polygon[i], m = v.length, a = v[0], b; j < m; ++j) {
          b = v[j];
          if (a[1] <= y) {
            if (b[1] > y && d3_cross2d(a, b, p) > 0) ++wn;
          } else {
            if (b[1] <= y && d3_cross2d(a, b, p) < 0) --wn;
          }
          a = b;
        }
      }
      return wn !== 0;
    }
    function interpolate(from, to, direction, listener) {
      var a = 0, a1 = 0;
      if (from == null || (a = corner(from, direction)) !== (a1 = corner(to, direction)) || comparePoints(from, to) < 0 ^ direction > 0) {
        do {
          listener.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0);
        } while ((a = (a + direction + 4) % 4) !== a1);
      } else {
        listener.point(to[0], to[1]);
      }
    }
    function pointVisible(x, y) {
      return x0 <= x && x <= x1 && y0 <= y && y <= y1;
    }
    function point(x, y) {
      if (pointVisible(x, y)) listener.point(x, y);
    }
    var x__, y__, v__, x_, y_, v_, first, clean;
    function lineStart() {
      clip.point = linePoint;
      if (polygon) polygon.push(ring = []);
      first = true;
      v_ = false;
      x_ = y_ = NaN;
    }
    function lineEnd() {
      if (segments) {
        linePoint(x__, y__);
        if (v__ && v_) bufferListener.rejoin();
        segments.push(bufferListener.buffer());
      }
      clip.point = point;
      if (v_) listener.lineEnd();
    }
    function linePoint(x, y) {
      x = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, x));
      y = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, y));
      var v = pointVisible(x, y);
      if (polygon) ring.push([ x, y ]);
      if (first) {
        x__ = x, y__ = y, v__ = v;
        first = false;
        if (v) {
          listener.lineStart();
          listener.point(x, y);
        }
      } else {
        if (v && v_) listener.point(x, y); else {
          var l = {
            a: {
              x: x_,
              y: y_
            },
            b: {
              x: x,
              y: y
            }
          };
          if (clipLine(l)) {
            if (!v_) {
              listener.lineStart();
              listener.point(l.a.x, l.a.y);
            }
            listener.point(l.b.x, l.b.y);
            if (!v) listener.lineEnd();
            clean = false;
          } else if (v) {
            listener.lineStart();
            listener.point(x, y);
            clean = false;
          }
        }
      }
      x_ = x, y_ = y, v_ = v;
    }
    return clip;
  };
  function corner(p, direction) {
    return abs(p[0] - x0) < ε ? direction > 0 ? 0 : 3 : abs(p[0] - x1) < ε ? direction > 0 ? 2 : 1 : abs(p[1] - y0) < ε ? direction > 0 ? 1 : 0 : direction > 0 ? 3 : 2;
  }
  function compare(a, b) {
    return comparePoints(a.x, b.x);
  }
  function comparePoints(a, b) {
    var ca = corner(a, 1), cb = corner(b, 1);
    return ca !== cb ? ca - cb : ca === 0 ? b[1] - a[1] : ca === 1 ? a[0] - b[0] : ca === 2 ? a[1] - b[1] : b[0] - a[0];
  }
}
function d3_geo_conic(projectAt) {
  var φ0 = 0, φ1 = π / 3, m = d3_geo_projectionMutator(projectAt), p = m(φ0, φ1);
  p.parallels = function(_) {
    if (!arguments.length) return [ φ0 / π * 180, φ1 / π * 180 ];
    return m(φ0 = _[0] * π / 180, φ1 = _[1] * π / 180);
  };
  return p;
}
function d3_geo_conicEqualArea(φ0, φ1) {
  var sinφ0 = Math.sin(φ0), n = (sinφ0 + Math.sin(φ1)) / 2, C = 1 + sinφ0 * (2 * n - sinφ0), ρ0 = Math.sqrt(C) / n;
  function forward(λ, φ) {
    var ρ = Math.sqrt(C - 2 * n * Math.sin(φ)) / n;
    return [ ρ * Math.sin(λ *= n), ρ0 - ρ * Math.cos(λ) ];
  }
  forward.invert = function(x, y) {
    var ρ0_y = ρ0 - y;
    return [ Math.atan2(x, ρ0_y) / n, d3_asin((C - (x * x + ρ0_y * ρ0_y) * n * n) / (2 * n)) ];
  };
  return forward;
}
(d3.geo.conicEqualArea = function() {
  return d3_geo_conic(d3_geo_conicEqualArea);
}).raw = d3_geo_conicEqualArea;
d3.geo.albers = function() {
  return d3.geo.conicEqualArea().rotate([ 96, 0 ]).center([ -.6, 38.7 ]).parallels([ 29.5, 45.5 ]).scale(1070);
};
d3.geo.albersUsa = function() {
  var lower48 = d3.geo.albers();
  var alaska = d3.geo.conicEqualArea().rotate([ 154, 0 ]).center([ -2, 58.5 ]).parallels([ 55, 65 ]);
  var hawaii = d3.geo.conicEqualArea().rotate([ 157, 0 ]).center([ -3, 19.9 ]).parallels([ 8, 18 ]);
  var point, pointStream = {
    point: function(x, y) {
      point = [ x, y ];
    }
  }, lower48Point, alaskaPoint, hawaiiPoint;
  function albersUsa(coordinates) {
    var x = coordinates[0], y = coordinates[1];
    point = null;
    (lower48Point(x, y), point) || (alaskaPoint(x, y), point) || hawaiiPoint(x, y);
    return point;
  }
  albersUsa.invert = function(coordinates) {
    var k = lower48.scale(), t = lower48.translate(), x = (coordinates[0] - t[0]) / k, y = (coordinates[1] - t[1]) / k;
    return (y >= .12 && y < .234 && x >= -.425 && x < -.214 ? alaska : y >= .166 && y < .234 && x >= -.214 && x < -.115 ? hawaii : lower48).invert(coordinates);
  };
  albersUsa.stream = function(stream) {
    var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);
    return {
      point: function(x, y) {
        lower48Stream.point(x, y);
        alaskaStream.point(x, y);
        hawaiiStream.point(x, y);
      },
      sphere: function() {
        lower48Stream.sphere();
        alaskaStream.sphere();
        hawaiiStream.sphere();
      },
      lineStart: function() {
        lower48Stream.lineStart();
        alaskaStream.lineStart();
        hawaiiStream.lineStart();
      },
      lineEnd: function() {
        lower48Stream.lineEnd();
        alaskaStream.lineEnd();
        hawaiiStream.lineEnd();
      },
      polygonStart: function() {
        lower48Stream.polygonStart();
        alaskaStream.polygonStart();
        hawaiiStream.polygonStart();
      },
      polygonEnd: function() {
        lower48Stream.polygonEnd();
        alaskaStream.polygonEnd();
        hawaiiStream.polygonEnd();
      }
    };
  };
  albersUsa.precision = function(_) {
    if (!arguments.length) return lower48.precision();
    lower48.precision(_);
    alaska.precision(_);
    hawaii.precision(_);
    return albersUsa;
  };
  albersUsa.scale = function(_) {
    if (!arguments.length) return lower48.scale();
    lower48.scale(_);
    alaska.scale(_ * .35);
    hawaii.scale(_);
    return albersUsa.translate(lower48.translate());
  };
  albersUsa.translate = function(_) {
    if (!arguments.length) return lower48.translate();
    var k = lower48.scale(), x = +_[0], y = +_[1];
    lower48Point = lower48.translate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;
    alaskaPoint = alaska.translate([ x - .307 * k, y + .201 * k ]).clipExtent([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
    hawaiiPoint = hawaii.translate([ x - .205 * k, y + .212 * k ]).clipExtent([ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
    return albersUsa;
  };
  return albersUsa.scale(1070);
};
var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = {
  point: d3_noop,
  lineStart: d3_noop,
  lineEnd: d3_noop,
  polygonStart: function() {
    d3_geo_pathAreaPolygon = 0;
    d3_geo_pathArea.lineStart = d3_geo_pathAreaRingStart;
  },
  polygonEnd: function() {
    d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop;
    d3_geo_pathAreaSum += abs(d3_geo_pathAreaPolygon / 2);
  }
};
function d3_geo_pathAreaRingStart() {
  var x00, y00, x0, y0;
  d3_geo_pathArea.point = function(x, y) {
    d3_geo_pathArea.point = nextPoint;
    x00 = x0 = x, y00 = y0 = y;
  };
  function nextPoint(x, y) {
    d3_geo_pathAreaPolygon += y0 * x - x0 * y;
    x0 = x, y0 = y;
  }
  d3_geo_pathArea.lineEnd = function() {
    nextPoint(x00, y00);
  };
}
var d3_geo_pathBoundsX0, d3_geo_pathBoundsY0, d3_geo_pathBoundsX1, d3_geo_pathBoundsY1;
var d3_geo_pathBounds = {
  point: d3_geo_pathBoundsPoint,
  lineStart: d3_noop,
  lineEnd: d3_noop,
  polygonStart: d3_noop,
  polygonEnd: d3_noop
};
function d3_geo_pathBoundsPoint(x, y) {
  if (x < d3_geo_pathBoundsX0) d3_geo_pathBoundsX0 = x;
  if (x > d3_geo_pathBoundsX1) d3_geo_pathBoundsX1 = x;
  if (y < d3_geo_pathBoundsY0) d3_geo_pathBoundsY0 = y;
  if (y > d3_geo_pathBoundsY1) d3_geo_pathBoundsY1 = y;
}
function d3_geo_pathBuffer() {
  var pointCircle = d3_geo_pathBufferCircle(4.5), buffer = [];
  var stream = {
    point: point,
    lineStart: function() {
      stream.point = pointLineStart;
    },
    lineEnd: lineEnd,
    polygonStart: function() {
      stream.lineEnd = lineEndPolygon;
    },
    polygonEnd: function() {
      stream.lineEnd = lineEnd;
      stream.point = point;
    },
    pointRadius: function(_) {
      pointCircle = d3_geo_pathBufferCircle(_);
      return stream;
    },
    result: function() {
      if (buffer.length) {
        var result = buffer.join("");
        buffer = [];
        return result;
      }
    }
  };
  function point(x, y) {
    buffer.push("M", x, ",", y, pointCircle);
  }
  function pointLineStart(x, y) {
    buffer.push("M", x, ",", y);
    stream.point = pointLine;
  }
  function pointLine(x, y) {
    buffer.push("L", x, ",", y);
  }
  function lineEnd() {
    stream.point = point;
  }
  function lineEndPolygon() {
    buffer.push("Z");
  }
  return stream;
}
function d3_geo_pathBufferCircle(radius) {
  return "m0," + radius + "a" + radius + "," + radius + " 0 1,1 0," + -2 * radius + "a" + radius + "," + radius + " 0 1,1 0," + 2 * radius + "z";
}
var d3_geo_pathCentroid = {
  point: d3_geo_pathCentroidPoint,
  lineStart: d3_geo_pathCentroidLineStart,
  lineEnd: d3_geo_pathCentroidLineEnd,
  polygonStart: function() {
    d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidRingStart;
  },
  polygonEnd: function() {
    d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
    d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidLineStart;
    d3_geo_pathCentroid.lineEnd = d3_geo_pathCentroidLineEnd;
  }
};
function d3_geo_pathCentroidPoint(x, y) {
  d3_geo_centroidX0 += x;
  d3_geo_centroidY0 += y;
  ++d3_geo_centroidZ0;
}
function d3_geo_pathCentroidLineStart() {
  var x0, y0;
  d3_geo_pathCentroid.point = function(x, y) {
    d3_geo_pathCentroid.point = nextPoint;
    d3_geo_pathCentroidPoint(x0 = x, y0 = y);
  };
  function nextPoint(x, y) {
    var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
    d3_geo_centroidX1 += z * (x0 + x) / 2;
    d3_geo_centroidY1 += z * (y0 + y) / 2;
    d3_geo_centroidZ1 += z;
    d3_geo_pathCentroidPoint(x0 = x, y0 = y);
  }
}
function d3_geo_pathCentroidLineEnd() {
  d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
}
function d3_geo_pathCentroidRingStart() {
  var x00, y00, x0, y0;
  d3_geo_pathCentroid.point = function(x, y) {
    d3_geo_pathCentroid.point = nextPoint;
    d3_geo_pathCentroidPoint(x00 = x0 = x, y00 = y0 = y);
  };
  function nextPoint(x, y) {
    var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
    d3_geo_centroidX1 += z * (x0 + x) / 2;
    d3_geo_centroidY1 += z * (y0 + y) / 2;
    d3_geo_centroidZ1 += z;
    z = y0 * x - x0 * y;
    d3_geo_centroidX2 += z * (x0 + x);
    d3_geo_centroidY2 += z * (y0 + y);
    d3_geo_centroidZ2 += z * 3;
    d3_geo_pathCentroidPoint(x0 = x, y0 = y);
  }
  d3_geo_pathCentroid.lineEnd = function() {
    nextPoint(x00, y00);
  };
}
function d3_geo_pathContext(context) {
  var pointRadius = 4.5;
  var stream = {
    point: point,
    lineStart: function() {
      stream.point = pointLineStart;
    },
    lineEnd: lineEnd,
    polygonStart: function() {
      stream.lineEnd = lineEndPolygon;
    },
    polygonEnd: function() {
      stream.lineEnd = lineEnd;
      stream.point = point;
    },
    pointRadius: function(_) {
      pointRadius = _;
      return stream;
    },
    result: d3_noop
  };
  function point(x, y) {
    context.moveTo(x + pointRadius, y);
    context.arc(x, y, pointRadius, 0, τ);
  }
  function pointLineStart(x, y) {
    context.moveTo(x, y);
    stream.point = pointLine;
  }
  function pointLine(x, y) {
    context.lineTo(x, y);
  }
  function lineEnd() {
    stream.point = point;
  }
  function lineEndPolygon() {
    context.closePath();
  }
  return stream;
}
function d3_geo_resample(project) {
  var δ2 = .5, cosMinDistance = Math.cos(30 * d3_radians), maxDepth = 16;
  function resample(stream) {
    return (maxDepth ? resampleRecursive : resampleNone)(stream);
  }
  function resampleNone(stream) {
    return d3_geo_transformPoint(stream, function(x, y) {
      x = project(x, y);
      stream.point(x[0], x[1]);
    });
  }
  function resampleRecursive(stream) {
    var λ00, φ00, x00, y00, a00, b00, c00, λ0, x0, y0, a0, b0, c0;
    var resample = {
      point: point,
      lineStart: lineStart,
      lineEnd: lineEnd,
      polygonStart: function() {
        stream.polygonStart();
        resample.lineStart = ringStart;
      },
      polygonEnd: function() {
        stream.polygonEnd();
        resample.lineStart = lineStart;
      }
    };
    function point(x, y) {
      x = project(x, y);
      stream.point(x[0], x[1]);
    }
    function lineStart() {
      x0 = NaN;
      resample.point = linePoint;
      stream.lineStart();
    }
    function linePoint(λ, φ) {
      var c = d3_geo_cartesian([ λ, φ ]), p = project(λ, φ);
      resampleLineTo(x0, y0, λ0, a0, b0, c0, x0 = p[0], y0 = p[1], λ0 = λ, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);
      stream.point(x0, y0);
    }
    function lineEnd() {
      resample.point = point;
      stream.lineEnd();
    }
    function ringStart() {
      lineStart();
      resample.point = ringPoint;
      resample.lineEnd = ringEnd;
    }
    function ringPoint(λ, φ) {
      linePoint(λ00 = λ, φ00 = φ), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;
      resample.point = linePoint;
    }
    function ringEnd() {
      resampleLineTo(x0, y0, λ0, a0, b0, c0, x00, y00, λ00, a00, b00, c00, maxDepth, stream);
      resample.lineEnd = lineEnd;
      lineEnd();
    }
    return resample;
  }
  function resampleLineTo(x0, y0, λ0, a0, b0, c0, x1, y1, λ1, a1, b1, c1, depth, stream) {
    var dx = x1 - x0, dy = y1 - y0, d2 = dx * dx + dy * dy;
    if (d2 > 4 * δ2 && depth--) {
      var a = a0 + a1, b = b0 + b1, c = c0 + c1, m = Math.sqrt(a * a + b * b + c * c), φ2 = Math.asin(c /= m), λ2 = abs(abs(c) - 1) < ε || abs(λ0 - λ1) < ε ? (λ0 + λ1) / 2 : Math.atan2(b, a), p = project(λ2, φ2), x2 = p[0], y2 = p[1], dx2 = x2 - x0, dy2 = y2 - y0, dz = dy * dx2 - dx * dy2;
      if (dz * dz / d2 > δ2 || abs((dx * dx2 + dy * dy2) / d2 - .5) > .3 || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) {
        resampleLineTo(x0, y0, λ0, a0, b0, c0, x2, y2, λ2, a /= m, b /= m, c, depth, stream);
        stream.point(x2, y2);
        resampleLineTo(x2, y2, λ2, a, b, c, x1, y1, λ1, a1, b1, c1, depth, stream);
      }
    }
  }
  resample.precision = function(_) {
    if (!arguments.length) return Math.sqrt(δ2);
    maxDepth = (δ2 = _ * _) > 0 && 16;
    return resample;
  };
  return resample;
}
d3.geo.path = function() {
  var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;
  function path(object) {
    if (object) {
      if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
      if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
      d3.geo.stream(object, cacheStream);
    }
    return contextStream.result();
  }
  path.area = function(object) {
    d3_geo_pathAreaSum = 0;
    d3.geo.stream(object, projectStream(d3_geo_pathArea));
    return d3_geo_pathAreaSum;
  };
  path.centroid = function(object) {
    d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 = d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 = d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0;
    d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
    return d3_geo_centroidZ2 ? [ d3_geo_centroidX2 / d3_geo_centroidZ2, d3_geo_centroidY2 / d3_geo_centroidZ2 ] : d3_geo_centroidZ1 ? [ d3_geo_centroidX1 / d3_geo_centroidZ1, d3_geo_centroidY1 / d3_geo_centroidZ1 ] : d3_geo_centroidZ0 ? [ d3_geo_centroidX0 / d3_geo_centroidZ0, d3_geo_centroidY0 / d3_geo_centroidZ0 ] : [ NaN, NaN ];
  };
  path.bounds = function(object) {
    d3_geo_pathBoundsX1 = d3_geo_pathBoundsY1 = -(d3_geo_pathBoundsX0 = d3_geo_pathBoundsY0 = Infinity);
    d3.geo.stream(object, projectStream(d3_geo_pathBounds));
    return [ [ d3_geo_pathBoundsX0, d3_geo_pathBoundsY0 ], [ d3_geo_pathBoundsX1, d3_geo_pathBoundsY1 ] ];
  };
  path.projection = function(_) {
    if (!arguments.length) return projection;
    projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
    return reset();
  };
  path.context = function(_) {
    if (!arguments.length) return context;
    contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
    if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
    return reset();
  };
  path.pointRadius = function(_) {
    if (!arguments.length) return pointRadius;
    pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
    return path;
  };
  function reset() {
    cacheStream = null;
    return path;
  }
  return path.projection(d3.geo.albersUsa()).context(null);
};
function d3_geo_pathProjectStream(project) {
  var resample = d3_geo_resample(function(x, y) {
    return project([ x * d3_degrees, y * d3_degrees ]);
  });
  return function(stream) {
    return d3_geo_projectionRadians(resample(stream));
  };
}
d3.geo.transform = function(methods) {
  return {
    stream: function(stream) {
      var transform = new d3_geo_transform(stream);
      for (var k in methods) transform[k] = methods[k];
      return transform;
    }
  };
};
function d3_geo_transform(stream) {
  this.stream = stream;
}
d3_geo_transform.prototype = {
  point: function(x, y) {
    this.stream.point(x, y);
  },
  sphere: function() {
    this.stream.sphere();
  },
  lineStart: function() {
    this.stream.lineStart();
  },
  lineEnd: function() {
    this.stream.lineEnd();
  },
  polygonStart: function() {
    this.stream.polygonStart();
  },
  polygonEnd: function() {
    this.stream.polygonEnd();
  }
};
function d3_geo_transformPoint(stream, point) {
  return {
    point: point,
    sphere: function() {
      stream.sphere();
    },
    lineStart: function() {
      stream.lineStart();
    },
    lineEnd: function() {
      stream.lineEnd();
    },
    polygonStart: function() {
      stream.polygonStart();
    },
    polygonEnd: function() {
      stream.polygonEnd();
    }
  };
}
d3.geo.projection = d3_geo_projection;
d3.geo.projectionMutator = d3_geo_projectionMutator;
function d3_geo_projection(project) {
  return d3_geo_projectionMutator(function() {
    return project;
  })();
}
function d3_geo_projectionMutator(projectAt) {
  var project, rotate, projectRotate, projectResample = d3_geo_resample(function(x, y) {
    x = project(x, y);
    return [ x[0] * k + δx, δy - x[1] * k ];
  }), k = 150, x = 480, y = 250, λ = 0, φ = 0, δλ = 0, δφ = 0, δγ = 0, δx, δy, preclip = d3_geo_clipAntimeridian, postclip = d3_identity, clipAngle = null, clipExtent = null, stream;
  function projection(point) {
    point = projectRotate(point[0] * d3_radians, point[1] * d3_radians);
    return [ point[0] * k + δx, δy - point[1] * k ];
  }
  function invert(point) {
    point = projectRotate.invert((point[0] - δx) / k, (δy - point[1]) / k);
    return point && [ point[0] * d3_degrees, point[1] * d3_degrees ];
  }
  projection.stream = function(output) {
    if (stream) stream.valid = false;
    stream = d3_geo_projectionRadians(preclip(rotate, projectResample(postclip(output))));
    stream.valid = true;
    return stream;
  };
  projection.clipAngle = function(_) {
    if (!arguments.length) return clipAngle;
    preclip = _ == null ? (clipAngle = _, d3_geo_clipAntimeridian) : d3_geo_clipCircle((clipAngle = +_) * d3_radians);
    return invalidate();
  };
  projection.clipExtent = function(_) {
    if (!arguments.length) return clipExtent;
    clipExtent = _;
    postclip = _ ? d3_geo_clipExtent(_[0][0], _[0][1], _[1][0], _[1][1]) : d3_identity;
    return invalidate();
  };
  projection.scale = function(_) {
    if (!arguments.length) return k;
    k = +_;
    return reset();
  };
  projection.translate = function(_) {
    if (!arguments.length) return [ x, y ];
    x = +_[0];
    y = +_[1];
    return reset();
  };
  projection.center = function(_) {
    if (!arguments.length) return [ λ * d3_degrees, φ * d3_degrees ];
    λ = _[0] % 360 * d3_radians;
    φ = _[1] % 360 * d3_radians;
    return reset();
  };
  projection.rotate = function(_) {
    if (!arguments.length) return [ δλ * d3_degrees, δφ * d3_degrees, δγ * d3_degrees ];
    δλ = _[0] % 360 * d3_radians;
    δφ = _[1] % 360 * d3_radians;
    δγ = _.length > 2 ? _[2] % 360 * d3_radians : 0;
    return reset();
  };
  d3.rebind(projection, projectResample, "precision");
  function reset() {
    projectRotate = d3_geo_compose(rotate = d3_geo_rotation(δλ, δφ, δγ), project);
    var center = project(λ, φ);
    δx = x - center[0] * k;
    δy = y + center[1] * k;
    return invalidate();
  }
  function invalidate() {
    if (stream) stream.valid = false, stream = null;
    return projection;
  }
  return function() {
    project = projectAt.apply(this, arguments);
    projection.invert = project.invert && invert;
    return reset();
  };
}
function d3_geo_projectionRadians(stream) {
  return d3_geo_transformPoint(stream, function(x, y) {
    stream.point(x * d3_radians, y * d3_radians);
  });
}
function d3_geo_equirectangular(λ, φ) {
  return [ λ, φ ];
}
(d3.geo.equirectangular = function() {
  return d3_geo_projection(d3_geo_equirectangular);
}).raw = d3_geo_equirectangular.invert = d3_geo_equirectangular;
d3.geo.rotation = function(rotate) {
  rotate = d3_geo_rotation(rotate[0] % 360 * d3_radians, rotate[1] * d3_radians, rotate.length > 2 ? rotate[2] * d3_radians : 0);
  function forward(coordinates) {
    coordinates = rotate(coordinates[0] * d3_radians, coordinates[1] * d3_radians);
    return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates;
  }
  forward.invert = function(coordinates) {
    coordinates = rotate.invert(coordinates[0] * d3_radians, coordinates[1] * d3_radians);
    return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates;
  };
  return forward;
};
function d3_geo_identityRotation(λ, φ) {
  return [ λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ ];
}
d3_geo_identityRotation.invert = d3_geo_equirectangular;
function d3_geo_rotation(δλ, δφ, δγ) {
  return δλ ? δφ || δγ ? d3_geo_compose(d3_geo_rotationλ(δλ), d3_geo_rotationφγ(δφ, δγ)) : d3_geo_rotationλ(δλ) : δφ || δγ ? d3_geo_rotationφγ(δφ, δγ) : d3_geo_identityRotation;
}
function d3_geo_forwardRotationλ(δλ) {
  return function(λ, φ) {
    return λ += δλ, [ λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ ];
  };
}
function d3_geo_rotationλ(δλ) {
  var rotation = d3_geo_forwardRotationλ(δλ);
  rotation.invert = d3_geo_forwardRotationλ(-δλ);
  return rotation;
}
function d3_geo_rotationφγ(δφ, δγ) {
  var cosδφ = Math.cos(δφ), sinδφ = Math.sin(δφ), cosδγ = Math.cos(δγ), sinδγ = Math.sin(δγ);
  function rotation(λ, φ) {
    var cosφ = Math.cos(φ), x = Math.cos(λ) * cosφ, y = Math.sin(λ) * cosφ, z = Math.sin(φ), k = z * cosδφ + x * sinδφ;
    return [ Math.atan2(y * cosδγ - k * sinδγ, x * cosδφ - z * sinδφ), d3_asin(k * cosδγ + y * sinδγ) ];
  }
  rotation.invert = function(λ, φ) {
    var cosφ = Math.cos(φ), x = Math.cos(λ) * cosφ, y = Math.sin(λ) * cosφ, z = Math.sin(φ), k = z * cosδγ - y * sinδγ;
    return [ Math.atan2(y * cosδγ + z * sinδγ, x * cosδφ + k * sinδφ), d3_asin(k * cosδφ - x * sinδφ) ];
  };
  return rotation;
}
d3.geo.circle = function() {
  var origin = [ 0, 0 ], angle, precision = 6, interpolate;
  function circle() {
    var center = typeof origin === "function" ? origin.apply(this, arguments) : origin, rotate = d3_geo_rotation(-center[0] * d3_radians, -center[1] * d3_radians, 0).invert, ring = [];
    interpolate(null, null, 1, {
      point: function(x, y) {
        ring.push(x = rotate(x, y));
        x[0] *= d3_degrees, x[1] *= d3_degrees;
      }
    });
    return {
      type: "Polygon",
      coordinates: [ ring ]
    };
  }
  circle.origin = function(x) {
    if (!arguments.length) return origin;
    origin = x;
    return circle;
  };
  circle.angle = function(x) {
    if (!arguments.length) return angle;
    interpolate = d3_geo_circleInterpolate((angle = +x) * d3_radians, precision * d3_radians);
    return circle;
  };
  circle.precision = function(_) {
    if (!arguments.length) return precision;
    interpolate = d3_geo_circleInterpolate(angle * d3_radians, (precision = +_) * d3_radians);
    return circle;
  };
  return circle.angle(90);
};
function d3_geo_circleInterpolate(radius, precision) {
  var cr = Math.cos(radius), sr = Math.sin(radius);
  return function(from, to, direction, listener) {
    var step = direction * precision;
    if (from != null) {
      from = d3_geo_circleAngle(cr, from);
      to = d3_geo_circleAngle(cr, to);
      if (direction > 0 ? from < to : from > to) from += direction * τ;
    } else {
      from = radius + direction * τ;
      to = radius - .5 * step;
    }
    for (var point, t = from; direction > 0 ? t > to : t < to; t -= step) {
      listener.point((point = d3_geo_spherical([ cr, -sr * Math.cos(t), -sr * Math.sin(t) ]))[0], point[1]);
    }
  };
}
function d3_geo_circleAngle(cr, point) {
  var a = d3_geo_cartesian(point);
  a[0] -= cr;
  d3_geo_cartesianNormalize(a);
  var angle = d3_acos(-a[1]);
  return ((-a[2] < 0 ? -angle : angle) + 2 * Math.PI - ε) % (2 * Math.PI);
}
d3.geo.distance = function(a, b) {
  var Δλ = (b[0] - a[0]) * d3_radians, φ0 = a[1] * d3_radians, φ1 = b[1] * d3_radians, sinΔλ = Math.sin(Δλ), cosΔλ = Math.cos(Δλ), sinφ0 = Math.sin(φ0), cosφ0 = Math.cos(φ0), sinφ1 = Math.sin(φ1), cosφ1 = Math.cos(φ1), t;
  return Math.atan2(Math.sqrt((t = cosφ1 * sinΔλ) * t + (t = cosφ0 * sinφ1 - sinφ0 * cosφ1 * cosΔλ) * t), sinφ0 * sinφ1 + cosφ0 * cosφ1 * cosΔλ);
};
d3.geo.graticule = function() {
  var x1, x0, X1, X0, y1, y0, Y1, Y0, dx = 10, dy = dx, DX = 90, DY = 360, x, y, X, Y, precision = 2.5;
  function graticule() {
    return {
      type: "MultiLineString",
      coordinates: lines()
    };
  }
  function lines() {
    return d3.range(Math.ceil(X0 / DX) * DX, X1, DX).map(X).concat(d3.range(Math.ceil(Y0 / DY) * DY, Y1, DY).map(Y)).concat(d3.range(Math.ceil(x0 / dx) * dx, x1, dx).filter(function(x) {
      return abs(x % DX) > ε;
    }).map(x)).concat(d3.range(Math.ceil(y0 / dy) * dy, y1, dy).filter(function(y) {
      return abs(y % DY) > ε;
    }).map(y));
  }
  graticule.lines = function() {
    return lines().map(function(coordinates) {
      return {
        type: "LineString",
        coordinates: coordinates
      };
    });
  };
  graticule.outline = function() {
    return {
      type: "Polygon",
      coordinates: [ X(X0).concat(Y(Y1).slice(1), X(X1).reverse().slice(1), Y(Y0).reverse().slice(1)) ]
    };
  };
  graticule.extent = function(_) {
    if (!arguments.length) return graticule.minorExtent();
    return graticule.majorExtent(_).minorExtent(_);
  };
  graticule.majorExtent = function(_) {
    if (!arguments.length) return [ [ X0, Y0 ], [ X1, Y1 ] ];
    X0 = +_[0][0], X1 = +_[1][0];
    Y0 = +_[0][1], Y1 = +_[1][1];
    if (X0 > X1) _ = X0, X0 = X1, X1 = _;
    if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _;
    return graticule.precision(precision);
  };
  graticule.minorExtent = function(_) {
    if (!arguments.length) return [ [ x0, y0 ], [ x1, y1 ] ];
    x0 = +_[0][0], x1 = +_[1][0];
    y0 = +_[0][1], y1 = +_[1][1];
    if (x0 > x1) _ = x0, x0 = x1, x1 = _;
    if (y0 > y1) _ = y0, y0 = y1, y1 = _;
    return graticule.precision(precision);
  };
  graticule.step = function(_) {
    if (!arguments.length) return graticule.minorStep();
    return graticule.majorStep(_).minorStep(_);
  };
  graticule.majorStep = function(_) {
    if (!arguments.length) return [ DX, DY ];
    DX = +_[0], DY = +_[1];
    return graticule;
  };
  graticule.minorStep = function(_) {
    if (!arguments.length) return [ dx, dy ];
    dx = +_[0], dy = +_[1];
    return graticule;
  };
  graticule.precision = function(_) {
    if (!arguments.length) return precision;
    precision = +_;
    x = d3_geo_graticuleX(y0, y1, 90);
    y = d3_geo_graticuleY(x0, x1, precision);
    X = d3_geo_graticuleX(Y0, Y1, 90);
    Y = d3_geo_graticuleY(X0, X1, precision);
    return graticule;
  };
  return graticule.majorExtent([ [ -180, -90 + ε ], [ 180, 90 - ε ] ]).minorExtent([ [ -180, -80 - ε ], [ 180, 80 + ε ] ]);
};
function d3_geo_graticuleX(y0, y1, dy) {
  var y = d3.range(y0, y1 - ε, dy).concat(y1);
  return function(x) {
    return y.map(function(y) {
      return [ x, y ];
    });
  };
}
function d3_geo_graticuleY(x0, x1, dx) {
  var x = d3.range(x0, x1 - ε, dx).concat(x1);
  return function(y) {
    return x.map(function(x) {
      return [ x, y ];
    });
  };
}
function d3_source(d) {
  return d.source;
}
function d3_target(d) {
  return d.target;
}
d3.geo.greatArc = function() {
  var source = d3_source, source_, target = d3_target, target_;
  function greatArc() {
    return {
      type: "LineString",
      coordinates: [ source_ || source.apply(this, arguments), target_ || target.apply(this, arguments) ]
    };
  }
  greatArc.distance = function() {
    return d3.geo.distance(source_ || source.apply(this, arguments), target_ || target.apply(this, arguments));
  };
  greatArc.source = function(_) {
    if (!arguments.length) return source;
    source = _, source_ = typeof _ === "function" ? null : _;
    return greatArc;
  };
  greatArc.target = function(_) {
    if (!arguments.length) return target;
    target = _, target_ = typeof _ === "function" ? null : _;
    return greatArc;
  };
  greatArc.precision = function() {
    return arguments.length ? greatArc : 0;
  };
  return greatArc;
};
d3.geo.interpolate = function(source, target) {
  return d3_geo_interpolate(source[0] * d3_radians, source[1] * d3_radians, target[0] * d3_radians, target[1] * d3_radians);
};
function d3_geo_interpolate(x0, y0, x1, y1) {
  var cy0 = Math.cos(y0), sy0 = Math.sin(y0), cy1 = Math.cos(y1), sy1 = Math.sin(y1), kx0 = cy0 * Math.cos(x0), ky0 = cy0 * Math.sin(x0), kx1 = cy1 * Math.cos(x1), ky1 = cy1 * Math.sin(x1), d = 2 * Math.asin(Math.sqrt(d3_haversin(y1 - y0) + cy0 * cy1 * d3_haversin(x1 - x0))), k = 1 / Math.sin(d);
  var interpolate = d ? function(t) {
    var B = Math.sin(t *= d) * k, A = Math.sin(d - t) * k, x = A * kx0 + B * kx1, y = A * ky0 + B * ky1, z = A * sy0 + B * sy1;
    return [ Math.atan2(y, x) * d3_degrees, Math.atan2(z, Math.sqrt(x * x + y * y)) * d3_degrees ];
  } : function() {
    return [ x0 * d3_degrees, y0 * d3_degrees ];
  };
  interpolate.distance = d;
  return interpolate;
}
d3.geo.length = function(object) {
  d3_geo_lengthSum = 0;
  d3.geo.stream(object, d3_geo_length);
  return d3_geo_lengthSum;
};
var d3_geo_lengthSum;
var d3_geo_length = {
  sphere: d3_noop,
  point: d3_noop,
  lineStart: d3_geo_lengthLineStart,
  lineEnd: d3_noop,
  polygonStart: d3_noop,
  polygonEnd: d3_noop
};
function d3_geo_lengthLineStart() {
  var λ0, sinφ0, cosφ0;
  d3_geo_length.point = function(λ, φ) {
    λ0 = λ * d3_radians, sinφ0 = Math.sin(φ *= d3_radians), cosφ0 = Math.cos(φ);
    d3_geo_length.point = nextPoint;
  };
  d3_geo_length.lineEnd = function() {
    d3_geo_length.point = d3_geo_length.lineEnd = d3_noop;
  };
  function nextPoint(λ, φ) {
    var sinφ = Math.sin(φ *= d3_radians), cosφ = Math.cos(φ), t = abs((λ *= d3_radians) - λ0), cosΔλ = Math.cos(t);
    d3_geo_lengthSum += Math.atan2(Math.sqrt((t = cosφ * Math.sin(t)) * t + (t = cosφ0 * sinφ - sinφ0 * cosφ * cosΔλ) * t), sinφ0 * sinφ + cosφ0 * cosφ * cosΔλ);
    λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ;
  }
}
function d3_geo_azimuthal(scale, angle) {
  function azimuthal(λ, φ) {
    var cosλ = Math.cos(λ), cosφ = Math.cos(φ), k = scale(cosλ * cosφ);
    return [ k * cosφ * Math.sin(λ), k * Math.sin(φ) ];
  }
  azimuthal.invert = function(x, y) {
    var ρ = Math.sqrt(x * x + y * y), c = angle(ρ), sinc = Math.sin(c), cosc = Math.cos(c);
    return [ Math.atan2(x * sinc, ρ * cosc), Math.asin(ρ && y * sinc / ρ) ];
  };
  return azimuthal;
}
var d3_geo_azimuthalEqualArea = d3_geo_azimuthal(function(cosλcosφ) {
  return Math.sqrt(2 / (1 + cosλcosφ));
}, function(ρ) {
  return 2 * Math.asin(ρ / 2);
});
(d3.geo.azimuthalEqualArea = function() {
  return d3_geo_projection(d3_geo_azimuthalEqualArea);
}).raw = d3_geo_azimuthalEqualArea;
var d3_geo_azimuthalEquidistant = d3_geo_azimuthal(function(cosλcosφ) {
  var c = Math.acos(cosλcosφ);
  return c && c / Math.sin(c);
}, d3_identity);
(d3.geo.azimuthalEquidistant = function() {
  return d3_geo_projection(d3_geo_azimuthalEquidistant);
}).raw = d3_geo_azimuthalEquidistant;
function d3_geo_conicConformal(φ0, φ1) {
  var cosφ0 = Math.cos(φ0), t = function(φ) {
    return Math.tan(π / 4 + φ / 2);
  }, n = φ0 === φ1 ? Math.sin(φ0) : Math.log(cosφ0 / Math.cos(φ1)) / Math.log(t(φ1) / t(φ0)), F = cosφ0 * Math.pow(t(φ0), n) / n;
  if (!n) return d3_geo_mercator;
  function forward(λ, φ) {
    if (F > 0) {
      if (φ < -halfπ + ε) φ = -halfπ + ε;
    } else {
      if (φ > halfπ - ε) φ = halfπ - ε;
    }
    var ρ = F / Math.pow(t(φ), n);
    return [ ρ * Math.sin(n * λ), F - ρ * Math.cos(n * λ) ];
  }
  forward.invert = function(x, y) {
    var ρ0_y = F - y, ρ = d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y);
    return [ Math.atan2(x, ρ0_y) / n, 2 * Math.atan(Math.pow(F / ρ, 1 / n)) - halfπ ];
  };
  return forward;
}
(d3.geo.conicConformal = function() {
  return d3_geo_conic(d3_geo_conicConformal);
}).raw = d3_geo_conicConformal;
function d3_geo_conicEquidistant(φ0, φ1) {
  var cosφ0 = Math.cos(φ0), n = φ0 === φ1 ? Math.sin(φ0) : (cosφ0 - Math.cos(φ1)) / (φ1 - φ0), G = cosφ0 / n + φ0;
  if (abs(n) < ε) return d3_geo_equirectangular;
  function forward(λ, φ) {
    var ρ = G - φ;
    return [ ρ * Math.sin(n * λ), G - ρ * Math.cos(n * λ) ];
  }
  forward.invert = function(x, y) {
    var ρ0_y = G - y;
    return [ Math.atan2(x, ρ0_y) / n, G - d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y) ];
  };
  return forward;
}
(d3.geo.conicEquidistant = function() {
  return d3_geo_conic(d3_geo_conicEquidistant);
}).raw = d3_geo_conicEquidistant;
var d3_geo_gnomonic = d3_geo_azimuthal(function(cosλcosφ) {
  return 1 / cosλcosφ;
}, Math.atan);
(d3.geo.gnomonic = function() {
  return d3_geo_projection(d3_geo_gnomonic);
}).raw = d3_geo_gnomonic;
function d3_geo_mercator(λ, φ) {
  return [ λ, Math.log(Math.tan(π / 4 + φ / 2)) ];
}
d3_geo_mercator.invert = function(x, y) {
  return [ x, 2 * Math.atan(Math.exp(y)) - halfπ ];
};
function d3_geo_mercatorProjection(project) {
  var m = d3_geo_projection(project), scale = m.scale, translate = m.translate, clipExtent = m.clipExtent, clipAuto;
  m.scale = function() {
    var v = scale.apply(m, arguments);
    return v === m ? clipAuto ? m.clipExtent(null) : m : v;
  };
  m.translate = function() {
    var v = translate.apply(m, arguments);
    return v === m ? clipAuto ? m.clipExtent(null) : m : v;
  };
  m.clipExtent = function(_) {
    var v = clipExtent.apply(m, arguments);
    if (v === m) {
      if (clipAuto = _ == null) {
        var k = π * scale(), t = translate();
        clipExtent([ [ t[0] - k, t[1] - k ], [ t[0] + k, t[1] + k ] ]);
      }
    } else if (clipAuto) {
      v = null;
    }
    return v;
  };
  return m.clipExtent(null);
}
(d3.geo.mercator = function() {
  return d3_geo_mercatorProjection(d3_geo_mercator);
}).raw = d3_geo_mercator;
var d3_geo_orthographic = d3_geo_azimuthal(function() {
  return 1;
}, Math.asin);
(d3.geo.orthographic = function() {
  return d3_geo_projection(d3_geo_orthographic);
}).raw = d3_geo_orthographic;
var d3_geo_stereographic = d3_geo_azimuthal(function(cosλcosφ) {
  return 1 / (1 + cosλcosφ);
}, function(ρ) {
  return 2 * Math.atan(ρ);
});
(d3.geo.stereographic = function() {
  return d3_geo_projection(d3_geo_stereographic);
}).raw = d3_geo_stereographic;
function d3_geo_transverseMercator(λ, φ) {
  return [ Math.log(Math.tan(π / 4 + φ / 2)), -λ ];
}
d3_geo_transverseMercator.invert = function(x, y) {
  return [ -y, 2 * Math.atan(Math.exp(x)) - halfπ ];
};
(d3.geo.transverseMercator = function() {
  var projection = d3_geo_mercatorProjection(d3_geo_transverseMercator), center = projection.center, rotate = projection.rotate;
  projection.center = function(_) {
    return _ ? center([ -_[1], _[0] ]) : (_ = center(), [ _[1], -_[0] ]);
  };
  projection.rotate = function(_) {
    return _ ? rotate([ _[0], _[1], _.length > 2 ? _[2] + 90 : 90 ]) : (_ = rotate(), 
    [ _[0], _[1], _[2] - 90 ]);
  };
  return rotate([ 0, 0, 90 ]);
}).raw = d3_geo_transverseMercator;
d3.geom = {};
function d3_geom_pointX(d) {
  return d[0];
}
function d3_geom_pointY(d) {
  return d[1];
}
d3.geom.hull = function(vertices) {
  var x = d3_geom_pointX, y = d3_geom_pointY;
  if (arguments.length) return hull(vertices);
  function hull(data) {
    if (data.length < 3) return [];
    var fx = d3_functor(x), fy = d3_functor(y), i, n = data.length, points = [], flippedPoints = [];
    for (i = 0; i < n; i++) {
      points.push([ +fx.call(this, data[i], i), +fy.call(this, data[i], i), i ]);
    }
    points.sort(d3_geom_hullOrder);
    for (i = 0; i < n; i++) flippedPoints.push([ points[i][0], -points[i][1] ]);
    var upper = d3_geom_hullUpper(points), lower = d3_geom_hullUpper(flippedPoints);
    var skipLeft = lower[0] === upper[0], skipRight = lower[lower.length - 1] === upper[upper.length - 1], polygon = [];
    for (i = upper.length - 1; i >= 0; --i) polygon.push(data[points[upper[i]][2]]);
    for (i = +skipLeft; i < lower.length - skipRight; ++i) polygon.push(data[points[lower[i]][2]]);
    return polygon;
  }
  hull.x = function(_) {
    return arguments.length ? (x = _, hull) : x;
  };
  hull.y = function(_) {
    return arguments.length ? (y = _, hull) : y;
  };
  return hull;
};
function d3_geom_hullUpper(points) {
  var n = points.length, hull = [ 0, 1 ], hs = 2;
  for (var i = 2; i < n; i++) {
    while (hs > 1 && d3_cross2d(points[hull[hs - 2]], points[hull[hs - 1]], points[i]) <= 0) --hs;
    hull[hs++] = i;
  }
  return hull.slice(0, hs);
}
function d3_geom_hullOrder(a, b) {
  return a[0] - b[0] || a[1] - b[1];
}
d3.geom.polygon = function(coordinates) {
  d3_subclass(coordinates, d3_geom_polygonPrototype);
  return coordinates;
};
var d3_geom_polygonPrototype = d3.geom.polygon.prototype = [];
d3_geom_polygonPrototype.area = function() {
  var i = -1, n = this.length, a, b = this[n - 1], area = 0;
  while (++i < n) {
    a = b;
    b = this[i];
    area += a[1] * b[0] - a[0] * b[1];
  }
  return area * .5;
};
d3_geom_polygonPrototype.centroid = function(k) {
  var i = -1, n = this.length, x = 0, y = 0, a, b = this[n - 1], c;
  if (!arguments.length) k = -1 / (6 * this.area());
  while (++i < n) {
    a = b;
    b = this[i];
    c = a[0] * b[1] - b[0] * a[1];
    x += (a[0] + b[0]) * c;
    y += (a[1] + b[1]) * c;
  }
  return [ x * k, y * k ];
};
d3_geom_polygonPrototype.clip = function(subject) {
  var input, closed = d3_geom_polygonClosed(subject), i = -1, n = this.length - d3_geom_polygonClosed(this), j, m, a = this[n - 1], b, c, d;
  while (++i < n) {
    input = subject.slice();
    subject.length = 0;
    b = this[i];
    c = input[(m = input.length - closed) - 1];
    j = -1;
    while (++j < m) {
      d = input[j];
      if (d3_geom_polygonInside(d, a, b)) {
        if (!d3_geom_polygonInside(c, a, b)) {
          subject.push(d3_geom_polygonIntersect(c, d, a, b));
        }
        subject.push(d);
      } else if (d3_geom_polygonInside(c, a, b)) {
        subject.push(d3_geom_polygonIntersect(c, d, a, b));
      }
      c = d;
    }
    if (closed) subject.push(subject[0]);
    a = b;
  }
  return subject;
};
function d3_geom_polygonInside(p, a, b) {
  return (b[0] - a[0]) * (p[1] - a[1]) < (b[1] - a[1]) * (p[0] - a[0]);
}
function d3_geom_polygonIntersect(c, d, a, b) {
  var x1 = c[0], x3 = a[0], x21 = d[0] - x1, x43 = b[0] - x3, y1 = c[1], y3 = a[1], y21 = d[1] - y1, y43 = b[1] - y3, ua = (x43 * (y1 - y3) - y43 * (x1 - x3)) / (y43 * x21 - x43 * y21);
  return [ x1 + ua * x21, y1 + ua * y21 ];
}
function d3_geom_polygonClosed(coordinates) {
  var a = coordinates[0], b = coordinates[coordinates.length - 1];
  return !(a[0] - b[0] || a[1] - b[1]);
}
var d3_geom_voronoiEdges, d3_geom_voronoiCells, d3_geom_voronoiBeaches, d3_geom_voronoiBeachPool = [], d3_geom_voronoiFirstCircle, d3_geom_voronoiCircles, d3_geom_voronoiCirclePool = [];
function d3_geom_voronoiBeach() {
  d3_geom_voronoiRedBlackNode(this);
  this.edge = this.site = this.circle = null;
}
function d3_geom_voronoiCreateBeach(site) {
  var beach = d3_geom_voronoiBeachPool.pop() || new d3_geom_voronoiBeach();
  beach.site = site;
  return beach;
}
function d3_geom_voronoiDetachBeach(beach) {
  d3_geom_voronoiDetachCircle(beach);
  d3_geom_voronoiBeaches.remove(beach);
  d3_geom_voronoiBeachPool.push(beach);
  d3_geom_voronoiRedBlackNode(beach);
}
function d3_geom_voronoiRemoveBeach(beach) {
  var circle = beach.circle, x = circle.x, y = circle.cy, vertex = {
    x: x,
    y: y
  }, previous = beach.P, next = beach.N, disappearing = [ beach ];
  d3_geom_voronoiDetachBeach(beach);
  var lArc = previous;
  while (lArc.circle && abs(x - lArc.circle.x) < ε && abs(y - lArc.circle.cy) < ε) {
    previous = lArc.P;
    disappearing.unshift(lArc);
    d3_geom_voronoiDetachBeach(lArc);
    lArc = previous;
  }
  disappearing.unshift(lArc);
  d3_geom_voronoiDetachCircle(lArc);
  var rArc = next;
  while (rArc.circle && abs(x - rArc.circle.x) < ε && abs(y - rArc.circle.cy) < ε) {
    next = rArc.N;
    disappearing.push(rArc);
    d3_geom_voronoiDetachBeach(rArc);
    rArc = next;
  }
  disappearing.push(rArc);
  d3_geom_voronoiDetachCircle(rArc);
  var nArcs = disappearing.length, iArc;
  for (iArc = 1; iArc < nArcs; ++iArc) {
    rArc = disappearing[iArc];
    lArc = disappearing[iArc - 1];
    d3_geom_voronoiSetEdgeEnd(rArc.edge, lArc.site, rArc.site, vertex);
  }
  lArc = disappearing[0];
  rArc = disappearing[nArcs - 1];
  rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, rArc.site, null, vertex);
  d3_geom_voronoiAttachCircle(lArc);
  d3_geom_voronoiAttachCircle(rArc);
}
function d3_geom_voronoiAddBeach(site) {
  var x = site.x, directrix = site.y, lArc, rArc, dxl, dxr, node = d3_geom_voronoiBeaches._;
  while (node) {
    dxl = d3_geom_voronoiLeftBreakPoint(node, directrix) - x;
    if (dxl > ε) node = node.L; else {
      dxr = x - d3_geom_voronoiRightBreakPoint(node, directrix);
      if (dxr > ε) {
        if (!node.R) {
          lArc = node;
          break;
        }
        node = node.R;
      } else {
        if (dxl > -ε) {
          lArc = node.P;
          rArc = node;
        } else if (dxr > -ε) {
          lArc = node;
          rArc = node.N;
        } else {
          lArc = rArc = node;
        }
        break;
      }
    }
  }
  var newArc = d3_geom_voronoiCreateBeach(site);
  d3_geom_voronoiBeaches.insert(lArc, newArc);
  if (!lArc && !rArc) return;
  if (lArc === rArc) {
    d3_geom_voronoiDetachCircle(lArc);
    rArc = d3_geom_voronoiCreateBeach(lArc.site);
    d3_geom_voronoiBeaches.insert(newArc, rArc);
    newArc.edge = rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site);
    d3_geom_voronoiAttachCircle(lArc);
    d3_geom_voronoiAttachCircle(rArc);
    return;
  }
  if (!rArc) {
    newArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site);
    return;
  }
  d3_geom_voronoiDetachCircle(lArc);
  d3_geom_voronoiDetachCircle(rArc);
  var lSite = lArc.site, ax = lSite.x, ay = lSite.y, bx = site.x - ax, by = site.y - ay, rSite = rArc.site, cx = rSite.x - ax, cy = rSite.y - ay, d = 2 * (bx * cy - by * cx), hb = bx * bx + by * by, hc = cx * cx + cy * cy, vertex = {
    x: (cy * hb - by * hc) / d + ax,
    y: (bx * hc - cx * hb) / d + ay
  };
  d3_geom_voronoiSetEdgeEnd(rArc.edge, lSite, rSite, vertex);
  newArc.edge = d3_geom_voronoiCreateEdge(lSite, site, null, vertex);
  rArc.edge = d3_geom_voronoiCreateEdge(site, rSite, null, vertex);
  d3_geom_voronoiAttachCircle(lArc);
  d3_geom_voronoiAttachCircle(rArc);
}
function d3_geom_voronoiLeftBreakPoint(arc, directrix) {
  var site = arc.site, rfocx = site.x, rfocy = site.y, pby2 = rfocy - directrix;
  if (!pby2) return rfocx;
  var lArc = arc.P;
  if (!lArc) return -Infinity;
  site = lArc.site;
  var lfocx = site.x, lfocy = site.y, plby2 = lfocy - directrix;
  if (!plby2) return lfocx;
  var hl = lfocx - rfocx, aby2 = 1 / pby2 - 1 / plby2, b = hl / plby2;
  if (aby2) return (-b + Math.sqrt(b * b - 2 * aby2 * (hl * hl / (-2 * plby2) - lfocy + plby2 / 2 + rfocy - pby2 / 2))) / aby2 + rfocx;
  return (rfocx + lfocx) / 2;
}
function d3_geom_voronoiRightBreakPoint(arc, directrix) {
  var rArc = arc.N;
  if (rArc) return d3_geom_voronoiLeftBreakPoint(rArc, directrix);
  var site = arc.site;
  return site.y === directrix ? site.x : Infinity;
}
function d3_geom_voronoiCell(site) {
  this.site = site;
  this.edges = [];
}
d3_geom_voronoiCell.prototype.prepare = function() {
  var halfEdges = this.edges, iHalfEdge = halfEdges.length, edge;
  while (iHalfEdge--) {
    edge = halfEdges[iHalfEdge].edge;
    if (!edge.b || !edge.a) halfEdges.splice(iHalfEdge, 1);
  }
  halfEdges.sort(d3_geom_voronoiHalfEdgeOrder);
  return halfEdges.length;
};
function d3_geom_voronoiCloseCells(extent) {
  var x0 = extent[0][0], x1 = extent[1][0], y0 = extent[0][1], y1 = extent[1][1], x2, y2, x3, y3, cells = d3_geom_voronoiCells, iCell = cells.length, cell, iHalfEdge, halfEdges, nHalfEdges, start, end;
  while (iCell--) {
    cell = cells[iCell];
    if (!cell || !cell.prepare()) continue;
    halfEdges = cell.edges;
    nHalfEdges = halfEdges.length;
    iHalfEdge = 0;
    while (iHalfEdge < nHalfEdges) {
      end = halfEdges[iHalfEdge].end(), x3 = end.x, y3 = end.y;
      start = halfEdges[++iHalfEdge % nHalfEdges].start(), x2 = start.x, y2 = start.y;
      if (abs(x3 - x2) > ε || abs(y3 - y2) > ε) {
        halfEdges.splice(iHalfEdge, 0, new d3_geom_voronoiHalfEdge(d3_geom_voronoiCreateBorderEdge(cell.site, end, abs(x3 - x0) < ε && y1 - y3 > ε ? {
          x: x0,
          y: abs(x2 - x0) < ε ? y2 : y1
        } : abs(y3 - y1) < ε && x1 - x3 > ε ? {
          x: abs(y2 - y1) < ε ? x2 : x1,
          y: y1
        } : abs(x3 - x1) < ε && y3 - y0 > ε ? {
          x: x1,
          y: abs(x2 - x1) < ε ? y2 : y0
        } : abs(y3 - y0) < ε && x3 - x0 > ε ? {
          x: abs(y2 - y0) < ε ? x2 : x0,
          y: y0
        } : null), cell.site, null));
        ++nHalfEdges;
      }
    }
  }
}
function d3_geom_voronoiHalfEdgeOrder(a, b) {
  return b.angle - a.angle;
}
function d3_geom_voronoiCircle() {
  d3_geom_voronoiRedBlackNode(this);
  this.x = this.y = this.arc = this.site = this.cy = null;
}
function d3_geom_voronoiAttachCircle(arc) {
  var lArc = arc.P, rArc = arc.N;
  if (!lArc || !rArc) return;
  var lSite = lArc.site, cSite = arc.site, rSite = rArc.site;
  if (lSite === rSite) return;
  var bx = cSite.x, by = cSite.y, ax = lSite.x - bx, ay = lSite.y - by, cx = rSite.x - bx, cy = rSite.y - by;
  var d = 2 * (ax * cy - ay * cx);
  if (d >= -ε2) return;
  var ha = ax * ax + ay * ay, hc = cx * cx + cy * cy, x = (cy * ha - ay * hc) / d, y = (ax * hc - cx * ha) / d, cy = y + by;
  var circle = d3_geom_voronoiCirclePool.pop() || new d3_geom_voronoiCircle();
  circle.arc = arc;
  circle.site = cSite;
  circle.x = x + bx;
  circle.y = cy + Math.sqrt(x * x + y * y);
  circle.cy = cy;
  arc.circle = circle;
  var before = null, node = d3_geom_voronoiCircles._;
  while (node) {
    if (circle.y < node.y || circle.y === node.y && circle.x <= node.x) {
      if (node.L) node = node.L; else {
        before = node.P;
        break;
      }
    } else {
      if (node.R) node = node.R; else {
        before = node;
        break;
      }
    }
  }
  d3_geom_voronoiCircles.insert(before, circle);
  if (!before) d3_geom_voronoiFirstCircle = circle;
}
function d3_geom_voronoiDetachCircle(arc) {
  var circle = arc.circle;
  if (circle) {
    if (!circle.P) d3_geom_voronoiFirstCircle = circle.N;
    d3_geom_voronoiCircles.remove(circle);
    d3_geom_voronoiCirclePool.push(circle);
    d3_geom_voronoiRedBlackNode(circle);
    arc.circle = null;
  }
}
function d3_geom_voronoiClipEdges(extent) {
  var edges = d3_geom_voronoiEdges, clip = d3_geom_clipLine(extent[0][0], extent[0][1], extent[1][0], extent[1][1]), i = edges.length, e;
  while (i--) {
    e = edges[i];
    if (!d3_geom_voronoiConnectEdge(e, extent) || !clip(e) || abs(e.a.x - e.b.x) < ε && abs(e.a.y - e.b.y) < ε) {
      e.a = e.b = null;
      edges.splice(i, 1);
    }
  }
}
function d3_geom_voronoiConnectEdge(edge, extent) {
  var vb = edge.b;
  if (vb) return true;
  var va = edge.a, x0 = extent[0][0], x1 = extent[1][0], y0 = extent[0][1], y1 = extent[1][1], lSite = edge.l, rSite = edge.r, lx = lSite.x, ly = lSite.y, rx = rSite.x, ry = rSite.y, fx = (lx + rx) / 2, fy = (ly + ry) / 2, fm, fb;
  if (ry === ly) {
    if (fx < x0 || fx >= x1) return;
    if (lx > rx) {
      if (!va) va = {
        x: fx,
        y: y0
      }; else if (va.y >= y1) return;
      vb = {
        x: fx,
        y: y1
      };
    } else {
      if (!va) va = {
        x: fx,
        y: y1
      }; else if (va.y < y0) return;
      vb = {
        x: fx,
        y: y0
      };
    }
  } else {
    fm = (lx - rx) / (ry - ly);
    fb = fy - fm * fx;
    if (fm < -1 || fm > 1) {
      if (lx > rx) {
        if (!va) va = {
          x: (y0 - fb) / fm,
          y: y0
        }; else if (va.y >= y1) return;
        vb = {
          x: (y1 - fb) / fm,
          y: y1
        };
      } else {
        if (!va) va = {
          x: (y1 - fb) / fm,
          y: y1
        }; else if (va.y < y0) return;
        vb = {
          x: (y0 - fb) / fm,
          y: y0
        };
      }
    } else {
      if (ly < ry) {
        if (!va) va = {
          x: x0,
          y: fm * x0 + fb
        }; else if (va.x >= x1) return;
        vb = {
          x: x1,
          y: fm * x1 + fb
        };
      } else {
        if (!va) va = {
          x: x1,
          y: fm * x1 + fb
        }; else if (va.x < x0) return;
        vb = {
          x: x0,
          y: fm * x0 + fb
        };
      }
    }
  }
  edge.a = va;
  edge.b = vb;
  return true;
}
function d3_geom_voronoiEdge(lSite, rSite) {
  this.l = lSite;
  this.r = rSite;
  this.a = this.b = null;
}
function d3_geom_voronoiCreateEdge(lSite, rSite, va, vb) {
  var edge = new d3_geom_voronoiEdge(lSite, rSite);
  d3_geom_voronoiEdges.push(edge);
  if (va) d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, va);
  if (vb) d3_geom_voronoiSetEdgeEnd(edge, rSite, lSite, vb);
  d3_geom_voronoiCells[lSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, lSite, rSite));
  d3_geom_voronoiCells[rSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, rSite, lSite));
  return edge;
}
function d3_geom_voronoiCreateBorderEdge(lSite, va, vb) {
  var edge = new d3_geom_voronoiEdge(lSite, null);
  edge.a = va;
  edge.b = vb;
  d3_geom_voronoiEdges.push(edge);
  return edge;
}
function d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, vertex) {
  if (!edge.a && !edge.b) {
    edge.a = vertex;
    edge.l = lSite;
    edge.r = rSite;
  } else if (edge.l === rSite) {
    edge.b = vertex;
  } else {
    edge.a = vertex;
  }
}
function d3_geom_voronoiHalfEdge(edge, lSite, rSite) {
  var va = edge.a, vb = edge.b;
  this.edge = edge;
  this.site = lSite;
  this.angle = rSite ? Math.atan2(rSite.y - lSite.y, rSite.x - lSite.x) : edge.l === lSite ? Math.atan2(vb.x - va.x, va.y - vb.y) : Math.atan2(va.x - vb.x, vb.y - va.y);
}
d3_geom_voronoiHalfEdge.prototype = {
  start: function() {
    return this.edge.l === this.site ? this.edge.a : this.edge.b;
  },
  end: function() {
    return this.edge.l === this.site ? this.edge.b : this.edge.a;
  }
};
function d3_geom_voronoiRedBlackTree() {
  this._ = null;
}
function d3_geom_voronoiRedBlackNode(node) {
  node.U = node.C = node.L = node.R = node.P = node.N = null;
}
d3_geom_voronoiRedBlackTree.prototype = {
  insert: function(after, node) {
    var parent, grandpa, uncle;
    if (after) {
      node.P = after;
      node.N = after.N;
      if (after.N) after.N.P = node;
      after.N = node;
      if (after.R) {
        after = after.R;
        while (after.L) after = after.L;
        after.L = node;
      } else {
        after.R = node;
      }
      parent = after;
    } else if (this._) {
      after = d3_geom_voronoiRedBlackFirst(this._);
      node.P = null;
      node.N = after;
      after.P = after.L = node;
      parent = after;
    } else {
      node.P = node.N = null;
      this._ = node;
      parent = null;
    }
    node.L = node.R = null;
    node.U = parent;
    node.C = true;
    after = node;
    while (parent && parent.C) {
      grandpa = parent.U;
      if (parent === grandpa.L) {
        uncle = grandpa.R;
        if (uncle && uncle.C) {
          parent.C = uncle.C = false;
          grandpa.C = true;
          after = grandpa;
        } else {
          if (after === parent.R) {
            d3_geom_voronoiRedBlackRotateLeft(this, parent);
            after = parent;
            parent = after.U;
          }
          parent.C = false;
          grandpa.C = true;
          d3_geom_voronoiRedBlackRotateRight(this, grandpa);
        }
      } else {
        uncle = grandpa.L;
        if (uncle && uncle.C) {
          parent.C = uncle.C = false;
          grandpa.C = true;
          after = grandpa;
        } else {
          if (after === parent.L) {
            d3_geom_voronoiRedBlackRotateRight(this, parent);
            after = parent;
            parent = after.U;
          }
          parent.C = false;
          grandpa.C = true;
          d3_geom_voronoiRedBlackRotateLeft(this, grandpa);
        }
      }
      parent = after.U;
    }
    this._.C = false;
  },
  remove: function(node) {
    if (node.N) node.N.P = node.P;
    if (node.P) node.P.N = node.N;
    node.N = node.P = null;
    var parent = node.U, sibling, left = node.L, right = node.R, next, red;
    if (!left) next = right; else if (!right) next = left; else next = d3_geom_voronoiRedBlackFirst(right);
    if (parent) {
      if (parent.L === node) parent.L = next; else parent.R = next;
    } else {
      this._ = next;
    }
    if (left && right) {
      red = next.C;
      next.C = node.C;
      next.L = left;
      left.U = next;
      if (next !== right) {
        parent = next.U;
        next.U = node.U;
        node = next.R;
        parent.L = node;
        next.R = right;
        right.U = next;
      } else {
        next.U = parent;
        parent = next;
        node = next.R;
      }
    } else {
      red = node.C;
      node = next;
    }
    if (node) node.U = parent;
    if (red) return;
    if (node && node.C) {
      node.C = false;
      return;
    }
    do {
      if (node === this._) break;
      if (node === parent.L) {
        sibling = parent.R;
        if (sibling.C) {
          sibling.C = false;
          parent.C = true;
          d3_geom_voronoiRedBlackRotateLeft(this, parent);
          sibling = parent.R;
        }
        if (sibling.L && sibling.L.C || sibling.R && sibling.R.C) {
          if (!sibling.R || !sibling.R.C) {
            sibling.L.C = false;
            sibling.C = true;
            d3_geom_voronoiRedBlackRotateRight(this, sibling);
            sibling = parent.R;
          }
          sibling.C = parent.C;
          parent.C = sibling.R.C = false;
          d3_geom_voronoiRedBlackRotateLeft(this, parent);
          node = this._;
          break;
        }
      } else {
        sibling = parent.L;
        if (sibling.C) {
          sibling.C = false;
          parent.C = true;
          d3_geom_voronoiRedBlackRotateRight(this, parent);
          sibling = parent.L;
        }
        if (sibling.L && sibling.L.C || sibling.R && sibling.R.C) {
          if (!sibling.L || !sibling.L.C) {
            sibling.R.C = false;
            sibling.C = true;
            d3_geom_voronoiRedBlackRotateLeft(this, sibling);
            sibling = parent.L;
          }
          sibling.C = parent.C;
          parent.C = sibling.L.C = false;
          d3_geom_voronoiRedBlackRotateRight(this, parent);
          node = this._;
          break;
        }
      }
      sibling.C = true;
      node = parent;
      parent = parent.U;
    } while (!node.C);
    if (node) node.C = false;
  }
};
function d3_geom_voronoiRedBlackRotateLeft(tree, node) {
  var p = node, q = node.R, parent = p.U;
  if (parent) {
    if (parent.L === p) parent.L = q; else parent.R = q;
  } else {
    tree._ = q;
  }
  q.U = parent;
  p.U = q;
  p.R = q.L;
  if (p.R) p.R.U = p;
  q.L = p;
}
function d3_geom_voronoiRedBlackRotateRight(tree, node) {
  var p = node, q = node.L, parent = p.U;
  if (parent) {
    if (parent.L === p) parent.L = q; else parent.R = q;
  } else {
    tree._ = q;
  }
  q.U = parent;
  p.U = q;
  p.L = q.R;
  if (p.L) p.L.U = p;
  q.R = p;
}
function d3_geom_voronoiRedBlackFirst(node) {
  while (node.L) node = node.L;
  return node;
}
function d3_geom_voronoi(sites, bbox) {
  var site = sites.sort(d3_geom_voronoiVertexOrder).pop(), x0, y0, circle;
  d3_geom_voronoiEdges = [];
  d3_geom_voronoiCells = new Array(sites.length);
  d3_geom_voronoiBeaches = new d3_geom_voronoiRedBlackTree();
  d3_geom_voronoiCircles = new d3_geom_voronoiRedBlackTree();
  while (true) {
    circle = d3_geom_voronoiFirstCircle;
    if (site && (!circle || site.y < circle.y || site.y === circle.y && site.x < circle.x)) {
      if (site.x !== x0 || site.y !== y0) {
        d3_geom_voronoiCells[site.i] = new d3_geom_voronoiCell(site);
        d3_geom_voronoiAddBeach(site);
        x0 = site.x, y0 = site.y;
      }
      site = sites.pop();
    } else if (circle) {
      d3_geom_voronoiRemoveBeach(circle.arc);
    } else {
      break;
    }
  }
  if (bbox) d3_geom_voronoiClipEdges(bbox), d3_geom_voronoiCloseCells(bbox);
  var diagram = {
    cells: d3_geom_voronoiCells,
    edges: d3_geom_voronoiEdges
  };
  d3_geom_voronoiBeaches = d3_geom_voronoiCircles = d3_geom_voronoiEdges = d3_geom_voronoiCells = null;
  return diagram;
}
function d3_geom_voronoiVertexOrder(a, b) {
  return b.y - a.y || b.x - a.x;
}
d3.geom.voronoi = function(points) {
  var x = d3_geom_pointX, y = d3_geom_pointY, fx = x, fy = y, clipExtent = d3_geom_voronoiClipExtent;
  if (points) return voronoi(points);
  function voronoi(data) {
    var polygons = new Array(data.length), x0 = clipExtent[0][0], y0 = clipExtent[0][1], x1 = clipExtent[1][0], y1 = clipExtent[1][1];
    d3_geom_voronoi(sites(data), clipExtent).cells.forEach(function(cell, i) {
      var edges = cell.edges, site = cell.site, polygon = polygons[i] = edges.length ? edges.map(function(e) {
        var s = e.start();
        return [ s.x, s.y ];
      }) : site.x >= x0 && site.x <= x1 && site.y >= y0 && site.y <= y1 ? [ [ x0, y1 ], [ x1, y1 ], [ x1, y0 ], [ x0, y0 ] ] : [];
      polygon.point = data[i];
    });
    return polygons;
  }
  function sites(data) {
    return data.map(function(d, i) {
      return {
        x: Math.round(fx(d, i) / ε) * ε,
        y: Math.round(fy(d, i) / ε) * ε,
        i: i
      };
    });
  }
  voronoi.links = function(data) {
    return d3_geom_voronoi(sites(data)).edges.filter(function(edge) {
      return edge.l && edge.r;
    }).map(function(edge) {
      return {
        source: data[edge.l.i],
        target: data[edge.r.i]
      };
    });
  };
  voronoi.triangles = function(data) {
    var triangles = [];
    d3_geom_voronoi(sites(data)).cells.forEach(function(cell, i) {
      var site = cell.site, edges = cell.edges.sort(d3_geom_voronoiHalfEdgeOrder), j = -1, m = edges.length, e0, s0, e1 = edges[m - 1].edge, s1 = e1.l === site ? e1.r : e1.l;
      while (++j < m) {
        e0 = e1;
        s0 = s1;
        e1 = edges[j].edge;
        s1 = e1.l === site ? e1.r : e1.l;
        if (i < s0.i && i < s1.i && d3_geom_voronoiTriangleArea(site, s0, s1) < 0) {
          triangles.push([ data[i], data[s0.i], data[s1.i] ]);
        }
      }
    });
    return triangles;
  };
  voronoi.x = function(_) {
    return arguments.length ? (fx = d3_functor(x = _), voronoi) : x;
  };
  voronoi.y = function(_) {
    return arguments.length ? (fy = d3_functor(y = _), voronoi) : y;
  };
  voronoi.clipExtent = function(_) {
    if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent;
    clipExtent = _ == null ? d3_geom_voronoiClipExtent : _;
    return voronoi;
  };
  voronoi.size = function(_) {
    if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent && clipExtent[1];
    return voronoi.clipExtent(_ && [ [ 0, 0 ], _ ]);
  };
  return voronoi;
};
var d3_geom_voronoiClipExtent = [ [ -1e6, -1e6 ], [ 1e6, 1e6 ] ];
function d3_geom_voronoiTriangleArea(a, b, c) {
  return (a.x - c.x) * (b.y - a.y) - (a.x - b.x) * (c.y - a.y);
}
d3.geom.delaunay = function(vertices) {
  return d3.geom.voronoi().triangles(vertices);
};
d3.geom.quadtree = function(points, x1, y1, x2, y2) {
  var x = d3_geom_pointX, y = d3_geom_pointY, compat;
  if (compat = arguments.length) {
    x = d3_geom_quadtreeCompatX;
    y = d3_geom_quadtreeCompatY;
    if (compat === 3) {
      y2 = y1;
      x2 = x1;
      y1 = x1 = 0;
    }
    return quadtree(points);
  }
  function quadtree(data) {
    var d, fx = d3_functor(x), fy = d3_functor(y), xs, ys, i, n, x1_, y1_, x2_, y2_;
    if (x1 != null) {
      x1_ = x1, y1_ = y1, x2_ = x2, y2_ = y2;
    } else {
      x2_ = y2_ = -(x1_ = y1_ = Infinity);
      xs = [], ys = [];
      n = data.length;
      if (compat) for (i = 0; i < n; ++i) {
        d = data[i];
        if (d.x < x1_) x1_ = d.x;
        if (d.y < y1_) y1_ = d.y;
        if (d.x > x2_) x2_ = d.x;
        if (d.y > y2_) y2_ = d.y;
        xs.push(d.x);
        ys.push(d.y);
      } else for (i = 0; i < n; ++i) {
        var x_ = +fx(d = data[i], i), y_ = +fy(d, i);
        if (x_ < x1_) x1_ = x_;
        if (y_ < y1_) y1_ = y_;
        if (x_ > x2_) x2_ = x_;
        if (y_ > y2_) y2_ = y_;
        xs.push(x_);
        ys.push(y_);
      }
    }
    var dx = x2_ - x1_, dy = y2_ - y1_;
    if (dx > dy) y2_ = y1_ + dx; else x2_ = x1_ + dy;
    function insert(n, d, x, y, x1, y1, x2, y2) {
      if (isNaN(x) || isNaN(y)) return;
      if (n.leaf) {
        var nx = n.x, ny = n.y;
        if (nx != null) {
          if (abs(nx - x) + abs(ny - y) < .01) {
            insertChild(n, d, x, y, x1, y1, x2, y2);
          } else {
            var nPoint = n.point;
            n.x = n.y = n.point = null;
            insertChild(n, nPoint, nx, ny, x1, y1, x2, y2);
            insertChild(n, d, x, y, x1, y1, x2, y2);
          }
        } else {
          n.x = x, n.y = y, n.point = d;
        }
      } else {
        insertChild(n, d, x, y, x1, y1, x2, y2);
      }
    }
    function insertChild(n, d, x, y, x1, y1, x2, y2) {
      var xm = (x1 + x2) * .5, ym = (y1 + y2) * .5, right = x >= xm, below = y >= ym, i = below << 1 | right;
      n.leaf = false;
      n = n.nodes[i] || (n.nodes[i] = d3_geom_quadtreeNode());
      if (right) x1 = xm; else x2 = xm;
      if (below) y1 = ym; else y2 = ym;
      insert(n, d, x, y, x1, y1, x2, y2);
    }
    var root = d3_geom_quadtreeNode();
    root.add = function(d) {
      insert(root, d, +fx(d, ++i), +fy(d, i), x1_, y1_, x2_, y2_);
    };
    root.visit = function(f) {
      d3_geom_quadtreeVisit(f, root, x1_, y1_, x2_, y2_);
    };
    root.find = function(point) {
      return d3_geom_quadtreeFind(root, point[0], point[1], x1_, y1_, x2_, y2_);
    };
    i = -1;
    if (x1 == null) {
      while (++i < n) {
        insert(root, data[i], xs[i], ys[i], x1_, y1_, x2_, y2_);
      }
      --i;
    } else data.forEach(root.add);
    xs = ys = data = d = null;
    return root;
  }
  quadtree.x = function(_) {
    return arguments.length ? (x = _, quadtree) : x;
  };
  quadtree.y = function(_) {
    return arguments.length ? (y = _, quadtree) : y;
  };
  quadtree.extent = function(_) {
    if (!arguments.length) return x1 == null ? null : [ [ x1, y1 ], [ x2, y2 ] ];
    if (_ == null) x1 = y1 = x2 = y2 = null; else x1 = +_[0][0], y1 = +_[0][1], x2 = +_[1][0], 
    y2 = +_[1][1];
    return quadtree;
  };
  quadtree.size = function(_) {
    if (!arguments.length) return x1 == null ? null : [ x2 - x1, y2 - y1 ];
    if (_ == null) x1 = y1 = x2 = y2 = null; else x1 = y1 = 0, x2 = +_[0], y2 = +_[1];
    return quadtree;
  };
  return quadtree;
};
function d3_geom_quadtreeCompatX(d) {
  return d.x;
}
function d3_geom_quadtreeCompatY(d) {
  return d.y;
}
function d3_geom_quadtreeNode() {
  return {
    leaf: true,
    nodes: [],
    point: null,
    x: null,
    y: null
  };
}
function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) {
  if (!f(node, x1, y1, x2, y2)) {
    var sx = (x1 + x2) * .5, sy = (y1 + y2) * .5, children = node.nodes;
    if (children[0]) d3_geom_quadtreeVisit(f, children[0], x1, y1, sx, sy);
    if (children[1]) d3_geom_quadtreeVisit(f, children[1], sx, y1, x2, sy);
    if (children[2]) d3_geom_quadtreeVisit(f, children[2], x1, sy, sx, y2);
    if (children[3]) d3_geom_quadtreeVisit(f, children[3], sx, sy, x2, y2);
  }
}
function d3_geom_quadtreeFind(root, x, y, x0, y0, x3, y3) {
  var minDistance2 = Infinity, closestPoint;
  (function find(node, x1, y1, x2, y2) {
    if (x1 > x3 || y1 > y3 || x2 < x0 || y2 < y0) return;
    if (point = node.point) {
      var point, dx = x - node.x, dy = y - node.y, distance2 = dx * dx + dy * dy;
      if (distance2 < minDistance2) {
        var distance = Math.sqrt(minDistance2 = distance2);
        x0 = x - distance, y0 = y - distance;
        x3 = x + distance, y3 = y + distance;
        closestPoint = point;
      }
    }
    var children = node.nodes, xm = (x1 + x2) * .5, ym = (y1 + y2) * .5, right = x >= xm, below = y >= ym;
    for (var i = below << 1 | right, j = i + 4; i < j; ++i) {
      if (node = children[i & 3]) switch (i & 3) {
       case 0:
        find(node, x1, y1, xm, ym);
        break;

       case 1:
        find(node, xm, y1, x2, ym);
        break;

       case 2:
        find(node, x1, ym, xm, y2);
        break;

       case 3:
        find(node, xm, ym, x2, y2);
        break;
      }
    }
  })(root, x0, y0, x3, y3);
  return closestPoint;
}
d3.interpolateRgb = d3_interpolateRgb;
function d3_interpolateRgb(a, b) {
  a = d3.rgb(a);
  b = d3.rgb(b);
  var ar = a.r, ag = a.g, ab = a.b, br = b.r - ar, bg = b.g - ag, bb = b.b - ab;
  return function(t) {
    return "#" + d3_rgb_hex(Math.round(ar + br * t)) + d3_rgb_hex(Math.round(ag + bg * t)) + d3_rgb_hex(Math.round(ab + bb * t));
  };
}
d3.interpolateObject = d3_interpolateObject;
function d3_interpolateObject(a, b) {
  var i = {}, c = {}, k;
  for (k in a) {
    if (k in b) {
      i[k] = d3_interpolate(a[k], b[k]);
    } else {
      c[k] = a[k];
    }
  }
  for (k in b) {
    if (!(k in a)) {
      c[k] = b[k];
    }
  }
  return function(t) {
    for (k in i) c[k] = i[k](t);
    return c;
  };
}
d3.interpolateNumber = d3_interpolateNumber;
function d3_interpolateNumber(a, b) {
  a = +a, b = +b;
  return function(t) {
    return a * (1 - t) + b * t;
  };
}
d3.interpolateString = d3_interpolateString;
function d3_interpolateString(a, b) {
  var bi = d3_interpolate_numberA.lastIndex = d3_interpolate_numberB.lastIndex = 0, am, bm, bs, i = -1, s = [], q = [];
  a = a + "", b = b + "";
  while ((am = d3_interpolate_numberA.exec(a)) && (bm = d3_interpolate_numberB.exec(b))) {
    if ((bs = bm.index) > bi) {
      bs = b.slice(bi, bs);
      if (s[i]) s[i] += bs; else s[++i] = bs;
    }
    if ((am = am[0]) === (bm = bm[0])) {
      if (s[i]) s[i] += bm; else s[++i] = bm;
    } else {
      s[++i] = null;
      q.push({
        i: i,
        x: d3_interpolateNumber(am, bm)
      });
    }
    bi = d3_interpolate_numberB.lastIndex;
  }
  if (bi < b.length) {
    bs = b.slice(bi);
    if (s[i]) s[i] += bs; else s[++i] = bs;
  }
  return s.length < 2 ? q[0] ? (b = q[0].x, function(t) {
    return b(t) + "";
  }) : function() {
    return b;
  } : (b = q.length, function(t) {
    for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);
    return s.join("");
  });
}
var d3_interpolate_numberA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, d3_interpolate_numberB = new RegExp(d3_interpolate_numberA.source, "g");
d3.interpolate = d3_interpolate;
function d3_interpolate(a, b) {
  var i = d3.interpolators.length, f;
  while (--i >= 0 && !(f = d3.interpolators[i](a, b))) ;
  return f;
}
d3.interpolators = [ function(a, b) {
  var t = typeof b;
  return (t === "string" ? d3_rgb_names.has(b.toLowerCase()) || /^(#|rgb\(|hsl\()/i.test(b) ? d3_interpolateRgb : d3_interpolateString : b instanceof d3_color ? d3_interpolateRgb : Array.isArray(b) ? d3_interpolateArray : t === "object" && isNaN(b) ? d3_interpolateObject : d3_interpolateNumber)(a, b);
} ];
d3.interpolateArray = d3_interpolateArray;
function d3_interpolateArray(a, b) {
  var x = [], c = [], na = a.length, nb = b.length, n0 = Math.min(a.length, b.length), i;
  for (i = 0; i < n0; ++i) x.push(d3_interpolate(a[i], b[i]));
  for (;i < na; ++i) c[i] = a[i];
  for (;i < nb; ++i) c[i] = b[i];
  return function(t) {
    for (i = 0; i < n0; ++i) c[i] = x[i](t);
    return c;
  };
}
var d3_ease_default = function() {
  return d3_identity;
};
var d3_ease = d3.map({
  linear: d3_ease_default,
  poly: d3_ease_poly,
  quad: function() {
    return d3_ease_quad;
  },
  cubic: function() {
    return d3_ease_cubic;
  },
  sin: function() {
    return d3_ease_sin;
  },
  exp: function() {
    return d3_ease_exp;
  },
  circle: function() {
    return d3_ease_circle;
  },
  elastic: d3_ease_elastic,
  back: d3_ease_back,
  bounce: function() {
    return d3_ease_bounce;
  }
});
var d3_ease_mode = d3.map({
  "in": d3_identity,
  out: d3_ease_reverse,
  "in-out": d3_ease_reflect,
  "out-in": function(f) {
    return d3_ease_reflect(d3_ease_reverse(f));
  }
});
d3.ease = function(name) {
  var i = name.indexOf("-"), t = i >= 0 ? name.slice(0, i) : name, m = i >= 0 ? name.slice(i + 1) : "in";
  t = d3_ease.get(t) || d3_ease_default;
  m = d3_ease_mode.get(m) || d3_identity;
  return d3_ease_clamp(m(t.apply(null, d3_arraySlice.call(arguments, 1))));
};
function d3_ease_clamp(f) {
  return function(t) {
    return t <= 0 ? 0 : t >= 1 ? 1 : f(t);
  };
}
function d3_ease_reverse(f) {
  return function(t) {
    return 1 - f(1 - t);
  };
}
function d3_ease_reflect(f) {
  return function(t) {
    return .5 * (t < .5 ? f(2 * t) : 2 - f(2 - 2 * t));
  };
}
function d3_ease_quad(t) {
  return t * t;
}
function d3_ease_cubic(t) {
  return t * t * t;
}
function d3_ease_cubicInOut(t) {
  if (t <= 0) return 0;
  if (t >= 1) return 1;
  var t2 = t * t, t3 = t2 * t;
  return 4 * (t < .5 ? t3 : 3 * (t - t2) + t3 - .75);
}
function d3_ease_poly(e) {
  return function(t) {
    return Math.pow(t, e);
  };
}
function d3_ease_sin(t) {
  return 1 - Math.cos(t * halfπ);
}
function d3_ease_exp(t) {
  return Math.pow(2, 10 * (t - 1));
}
function d3_ease_circle(t) {
  return 1 - Math.sqrt(1 - t * t);
}
function d3_ease_elastic(a, p) {
  var s;
  if (arguments.length < 2) p = .45;
  if (arguments.length) s = p / τ * Math.asin(1 / a); else a = 1, s = p / 4;
  return function(t) {
    return 1 + a * Math.pow(2, -10 * t) * Math.sin((t - s) * τ / p);
  };
}
function d3_ease_back(s) {
  if (!s) s = 1.70158;
  return function(t) {
    return t * t * ((s + 1) * t - s);
  };
}
function d3_ease_bounce(t) {
  return t < 1 / 2.75 ? 7.5625 * t * t : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75 : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375 : 7.5625 * (t -= 2.625 / 2.75) * t + .984375;
}
d3.interpolateHcl = d3_interpolateHcl;
function d3_interpolateHcl(a, b) {
  a = d3.hcl(a);
  b = d3.hcl(b);
  var ah = a.h, ac = a.c, al = a.l, bh = b.h - ah, bc = b.c - ac, bl = b.l - al;
  if (isNaN(bc)) bc = 0, ac = isNaN(ac) ? b.c : ac;
  if (isNaN(bh)) bh = 0, ah = isNaN(ah) ? b.h : ah; else if (bh > 180) bh -= 360; else if (bh < -180) bh += 360;
  return function(t) {
    return d3_hcl_lab(ah + bh * t, ac + bc * t, al + bl * t) + "";
  };
}
d3.interpolateHsl = d3_interpolateHsl;
function d3_interpolateHsl(a, b) {
  a = d3.hsl(a);
  b = d3.hsl(b);
  var ah = a.h, as = a.s, al = a.l, bh = b.h - ah, bs = b.s - as, bl = b.l - al;
  if (isNaN(bs)) bs = 0, as = isNaN(as) ? b.s : as;
  if (isNaN(bh)) bh = 0, ah = isNaN(ah) ? b.h : ah; else if (bh > 180) bh -= 360; else if (bh < -180) bh += 360;
  return function(t) {
    return d3_hsl_rgb(ah + bh * t, as + bs * t, al + bl * t) + "";
  };
}
d3.interpolateLab = d3_interpolateLab;
function d3_interpolateLab(a, b) {
  a = d3.lab(a);
  b = d3.lab(b);
  var al = a.l, aa = a.a, ab = a.b, bl = b.l - al, ba = b.a - aa, bb = b.b - ab;
  return function(t) {
    return d3_lab_rgb(al + bl * t, aa + ba * t, ab + bb * t) + "";
  };
}
d3.interpolateRound = d3_interpolateRound;
function d3_interpolateRound(a, b) {
  b -= a;
  return function(t) {
    return Math.round(a + b * t);
  };
}
d3.transform = function(string) {
  var g = d3_document.createElementNS(d3.ns.prefix.svg, "g");
  return (d3.transform = function(string) {
    if (string != null) {
      g.setAttribute("transform", string);
      var t = g.transform.baseVal.consolidate();
    }
    return new d3_transform(t ? t.matrix : d3_transformIdentity);
  })(string);
};
function d3_transform(m) {
  var r0 = [ m.a, m.b ], r1 = [ m.c, m.d ], kx = d3_transformNormalize(r0), kz = d3_transformDot(r0, r1), ky = d3_transformNormalize(d3_transformCombine(r1, r0, -kz)) || 0;
  if (r0[0] * r1[1] < r1[0] * r0[1]) {
    r0[0] *= -1;
    r0[1] *= -1;
    kx *= -1;
    kz *= -1;
  }
  this.rotate = (kx ? Math.atan2(r0[1], r0[0]) : Math.atan2(-r1[0], r1[1])) * d3_degrees;
  this.translate = [ m.e, m.f ];
  this.scale = [ kx, ky ];
  this.skew = ky ? Math.atan2(kz, ky) * d3_degrees : 0;
}
d3_transform.prototype.toString = function() {
  return "translate(" + this.translate + ")rotate(" + this.rotate + ")skewX(" + this.skew + ")scale(" + this.scale + ")";
};
function d3_transformDot(a, b) {
  return a[0] * b[0] + a[1] * b[1];
}
function d3_transformNormalize(a) {
  var k = Math.sqrt(d3_transformDot(a, a));
  if (k) {
    a[0] /= k;
    a[1] /= k;
  }
  return k;
}
function d3_transformCombine(a, b, k) {
  a[0] += k * b[0];
  a[1] += k * b[1];
  return a;
}
var d3_transformIdentity = {
  a: 1,
  b: 0,
  c: 0,
  d: 1,
  e: 0,
  f: 0
};
d3.interpolateTransform = d3_interpolateTransform;
function d3_interpolateTransformPop(s) {
  return s.length ? s.pop() + "," : "";
}
function d3_interpolateTranslate(ta, tb, s, q) {
  if (ta[0] !== tb[0] || ta[1] !== tb[1]) {
    var i = s.push("translate(", null, ",", null, ")");
    q.push({
      i: i - 4,
      x: d3_interpolateNumber(ta[0], tb[0])
    }, {
      i: i - 2,
      x: d3_interpolateNumber(ta[1], tb[1])
    });
  } else if (tb[0] || tb[1]) {
    s.push("translate(" + tb + ")");
  }
}
function d3_interpolateRotate(ra, rb, s, q) {
  if (ra !== rb) {
    if (ra - rb > 180) rb += 360; else if (rb - ra > 180) ra += 360;
    q.push({
      i: s.push(d3_interpolateTransformPop(s) + "rotate(", null, ")") - 2,
      x: d3_interpolateNumber(ra, rb)
    });
  } else if (rb) {
    s.push(d3_interpolateTransformPop(s) + "rotate(" + rb + ")");
  }
}
function d3_interpolateSkew(wa, wb, s, q) {
  if (wa !== wb) {
    q.push({
      i: s.push(d3_interpolateTransformPop(s) + "skewX(", null, ")") - 2,
      x: d3_interpolateNumber(wa, wb)
    });
  } else if (wb) {
    s.push(d3_interpolateTransformPop(s) + "skewX(" + wb + ")");
  }
}
function d3_interpolateScale(ka, kb, s, q) {
  if (ka[0] !== kb[0] || ka[1] !== kb[1]) {
    var i = s.push(d3_interpolateTransformPop(s) + "scale(", null, ",", null, ")");
    q.push({
      i: i - 4,
      x: d3_interpolateNumber(ka[0], kb[0])
    }, {
      i: i - 2,
      x: d3_interpolateNumber(ka[1], kb[1])
    });
  } else if (kb[0] !== 1 || kb[1] !== 1) {
    s.push(d3_interpolateTransformPop(s) + "scale(" + kb + ")");
  }
}
function d3_interpolateTransform(a, b) {
  var s = [], q = [];
  a = d3.transform(a), b = d3.transform(b);
  d3_interpolateTranslate(a.translate, b.translate, s, q);
  d3_interpolateRotate(a.rotate, b.rotate, s, q);
  d3_interpolateSkew(a.skew, b.skew, s, q);
  d3_interpolateScale(a.scale, b.scale, s, q);
  a = b = null;
  return function(t) {
    var i = -1, n = q.length, o;
    while (++i < n) s[(o = q[i]).i] = o.x(t);
    return s.join("");
  };
}
function d3_uninterpolateNumber(a, b) {
  b = (b -= a = +a) || 1 / b;
  return function(x) {
    return (x - a) / b;
  };
}
function d3_uninterpolateClamp(a, b) {
  b = (b -= a = +a) || 1 / b;
  return function(x) {
    return Math.max(0, Math.min(1, (x - a) / b));
  };
}
d3.layout = {};
d3.layout.bundle = function() {
  return function(links) {
    var paths = [], i = -1, n = links.length;
    while (++i < n) paths.push(d3_layout_bundlePath(links[i]));
    return paths;
  };
};
function d3_layout_bundlePath(link) {
  var start = link.source, end = link.target, lca = d3_layout_bundleLeastCommonAncestor(start, end), points = [ start ];
  while (start !== lca) {
    start = start.parent;
    points.push(start);
  }
  var k = points.length;
  while (end !== lca) {
    points.splice(k, 0, end);
    end = end.parent;
  }
  return points;
}
function d3_layout_bundleAncestors(node) {
  var ancestors = [], parent = node.parent;
  while (parent != null) {
    ancestors.push(node);
    node = parent;
    parent = parent.parent;
  }
  ancestors.push(node);
  return ancestors;
}
function d3_layout_bundleLeastCommonAncestor(a, b) {
  if (a === b) return a;
  var aNodes = d3_layout_bundleAncestors(a), bNodes = d3_layout_bundleAncestors(b), aNode = aNodes.pop(), bNode = bNodes.pop(), sharedNode = null;
  while (aNode === bNode) {
    sharedNode = aNode;
    aNode = aNodes.pop();
    bNode = bNodes.pop();
  }
  return sharedNode;
}
d3.layout.chord = function() {
  var chord = {}, chords, groups, matrix, n, padding = 0, sortGroups, sortSubgroups, sortChords;
  function relayout() {
    var subgroups = {}, groupSums = [], groupIndex = d3.range(n), subgroupIndex = [], k, x, x0, i, j;
    chords = [];
    groups = [];
    k = 0, i = -1;
    while (++i < n) {
      x = 0, j = -1;
      while (++j < n) {
        x += matrix[i][j];
      }
      groupSums.push(x);
      subgroupIndex.push(d3.range(n));
      k += x;
    }
    if (sortGroups) {
      groupIndex.sort(function(a, b) {
        return sortGroups(groupSums[a], groupSums[b]);
      });
    }
    if (sortSubgroups) {
      subgroupIndex.forEach(function(d, i) {
        d.sort(function(a, b) {
          return sortSubgroups(matrix[i][a], matrix[i][b]);
        });
      });
    }
    k = (τ - padding * n) / k;
    x = 0, i = -1;
    while (++i < n) {
      x0 = x, j = -1;
      while (++j < n) {
        var di = groupIndex[i], dj = subgroupIndex[di][j], v = matrix[di][dj], a0 = x, a1 = x += v * k;
        subgroups[di + "-" + dj] = {
          index: di,
          subindex: dj,
          startAngle: a0,
          endAngle: a1,
          value: v
        };
      }
      groups[di] = {
        index: di,
        startAngle: x0,
        endAngle: x,
        value: groupSums[di]
      };
      x += padding;
    }
    i = -1;
    while (++i < n) {
      j = i - 1;
      while (++j < n) {
        var source = subgroups[i + "-" + j], target = subgroups[j + "-" + i];
        if (source.value || target.value) {
          chords.push(source.value < target.value ? {
            source: target,
            target: source
          } : {
            source: source,
            target: target
          });
        }
      }
    }
    if (sortChords) resort();
  }
  function resort() {
    chords.sort(function(a, b) {
      return sortChords((a.source.value + a.target.value) / 2, (b.source.value + b.target.value) / 2);
    });
  }
  chord.matrix = function(x) {
    if (!arguments.length) return matrix;
    n = (matrix = x) && matrix.length;
    chords = groups = null;
    return chord;
  };
  chord.padding = function(x) {
    if (!arguments.length) return padding;
    padding = x;
    chords = groups = null;
    return chord;
  };
  chord.sortGroups = function(x) {
    if (!arguments.length) return sortGroups;
    sortGroups = x;
    chords = groups = null;
    return chord;
  };
  chord.sortSubgroups = function(x) {
    if (!arguments.length) return sortSubgroups;
    sortSubgroups = x;
    chords = null;
    return chord;
  };
  chord.sortChords = function(x) {
    if (!arguments.length) return sortChords;
    sortChords = x;
    if (chords) resort();
    return chord;
  };
  chord.chords = function() {
    if (!chords) relayout();
    return chords;
  };
  chord.groups = function() {
    if (!groups) relayout();
    return groups;
  };
  return chord;
};
d3.layout.force = function() {
  var force = {}, event = d3.dispatch("start", "tick", "end"), timer, size = [ 1, 1 ], drag, alpha, friction = .9, linkDistance = d3_layout_forceLinkDistance, linkStrength = d3_layout_forceLinkStrength, charge = -30, chargeDistance2 = d3_layout_forceChargeDistance2, gravity = .1, theta2 = .64, nodes = [], links = [], distances, strengths, charges;
  function repulse(node) {
    return function(quad, x1, _, x2) {
      if (quad.point !== node) {
        var dx = quad.cx - node.x, dy = quad.cy - node.y, dw = x2 - x1, dn = dx * dx + dy * dy;
        if (dw * dw / theta2 < dn) {
          if (dn < chargeDistance2) {
            var k = quad.charge / dn;
            node.px -= dx * k;
            node.py -= dy * k;
          }
          return true;
        }
        if (quad.point && dn && dn < chargeDistance2) {
          var k = quad.pointCharge / dn;
          node.px -= dx * k;
          node.py -= dy * k;
        }
      }
      return !quad.charge;
    };
  }
  force.tick = function() {
    if ((alpha *= .99) < .005) {
      timer = null;
      event.end({
        type: "end",
        alpha: alpha = 0
      });
      return true;
    }
    var n = nodes.length, m = links.length, q, i, o, s, t, l, k, x, y;
    for (i = 0; i < m; ++i) {
      o = links[i];
      s = o.source;
      t = o.target;
      x = t.x - s.x;
      y = t.y - s.y;
      if (l = x * x + y * y) {
        l = alpha * strengths[i] * ((l = Math.sqrt(l)) - distances[i]) / l;
        x *= l;
        y *= l;
        t.x -= x * (k = s.weight + t.weight ? s.weight / (s.weight + t.weight) : .5);
        t.y -= y * k;
        s.x += x * (k = 1 - k);
        s.y += y * k;
      }
    }
    if (k = alpha * gravity) {
      x = size[0] / 2;
      y = size[1] / 2;
      i = -1;
      if (k) while (++i < n) {
        o = nodes[i];
        o.x += (x - o.x) * k;
        o.y += (y - o.y) * k;
      }
    }
    if (charge) {
      d3_layout_forceAccumulate(q = d3.geom.quadtree(nodes), alpha, charges);
      i = -1;
      while (++i < n) {
        if (!(o = nodes[i]).fixed) {
          q.visit(repulse(o));
        }
      }
    }
    i = -1;
    while (++i < n) {
      o = nodes[i];
      if (o.fixed) {
        o.x = o.px;
        o.y = o.py;
      } else {
        o.x -= (o.px - (o.px = o.x)) * friction;
        o.y -= (o.py - (o.py = o.y)) * friction;
      }
    }
    event.tick({
      type: "tick",
      alpha: alpha
    });
  };
  force.nodes = function(x) {
    if (!arguments.length) return nodes;
    nodes = x;
    return force;
  };
  force.links = function(x) {
    if (!arguments.length) return links;
    links = x;
    return force;
  };
  force.size = function(x) {
    if (!arguments.length) return size;
    size = x;
    return force;
  };
  force.linkDistance = function(x) {
    if (!arguments.length) return linkDistance;
    linkDistance = typeof x === "function" ? x : +x;
    return force;
  };
  force.distance = force.linkDistance;
  force.linkStrength = function(x) {
    if (!arguments.length) return linkStrength;
    linkStrength = typeof x === "function" ? x : +x;
    return force;
  };
  force.friction = function(x) {
    if (!arguments.length) return friction;
    friction = +x;
    return force;
  };
  force.charge = function(x) {
    if (!arguments.length) return charge;
    charge = typeof x === "function" ? x : +x;
    return force;
  };
  force.chargeDistance = function(x) {
    if (!arguments.length) return Math.sqrt(chargeDistance2);
    chargeDistance2 = x * x;
    return force;
  };
  force.gravity = function(x) {
    if (!arguments.length) return gravity;
    gravity = +x;
    return force;
  };
  force.theta = function(x) {
    if (!arguments.length) return Math.sqrt(theta2);
    theta2 = x * x;
    return force;
  };
  force.alpha = function(x) {
    if (!arguments.length) return alpha;
    x = +x;
    if (alpha) {
      if (x > 0) {
        alpha = x;
      } else {
        timer.c = null, timer.t = NaN, timer = null;
        event.end({
          type: "end",
          alpha: alpha = 0
        });
      }
    } else if (x > 0) {
      event.start({
        type: "start",
        alpha: alpha = x
      });
      timer = d3_timer(force.tick);
    }
    return force;
  };
  force.start = function() {
    var i, n = nodes.length, m = links.length, w = size[0], h = size[1], neighbors, o;
    for (i = 0; i < n; ++i) {
      (o = nodes[i]).index = i;
      o.weight = 0;
    }
    for (i = 0; i < m; ++i) {
      o = links[i];
      if (typeof o.source == "number") o.source = nodes[o.source];
      if (typeof o.target == "number") o.target = nodes[o.target];
      ++o.source.weight;
      ++o.target.weight;
    }
    for (i = 0; i < n; ++i) {
      o = nodes[i];
      if (isNaN(o.x)) o.x = position("x", w);
      if (isNaN(o.y)) o.y = position("y", h);
      if (isNaN(o.px)) o.px = o.x;
      if (isNaN(o.py)) o.py = o.y;
    }
    distances = [];
    if (typeof linkDistance === "function") for (i = 0; i < m; ++i) distances[i] = +linkDistance.call(this, links[i], i); else for (i = 0; i < m; ++i) distances[i] = linkDistance;
    strengths = [];
    if (typeof linkStrength === "function") for (i = 0; i < m; ++i) strengths[i] = +linkStrength.call(this, links[i], i); else for (i = 0; i < m; ++i) strengths[i] = linkStrength;
    charges = [];
    if (typeof charge === "function") for (i = 0; i < n; ++i) charges[i] = +charge.call(this, nodes[i], i); else for (i = 0; i < n; ++i) charges[i] = charge;
    function position(dimension, size) {
      if (!neighbors) {
        neighbors = new Array(n);
        for (j = 0; j < n; ++j) {
          neighbors[j] = [];
        }
        for (j = 0; j < m; ++j) {
          var o = links[j];
          neighbors[o.source.index].push(o.target);
          neighbors[o.target.index].push(o.source);
        }
      }
      var candidates = neighbors[i], j = -1, l = candidates.length, x;
      while (++j < l) if (!isNaN(x = candidates[j][dimension])) return x;
      return Math.random() * size;
    }
    return force.resume();
  };
  force.resume = function() {
    return force.alpha(.1);
  };
  force.stop = function() {
    return force.alpha(0);
  };
  force.drag = function() {
    if (!drag) drag = d3.behavior.drag().origin(d3_identity).on("dragstart.force", d3_layout_forceDragstart).on("drag.force", dragmove).on("dragend.force", d3_layout_forceDragend);
    if (!arguments.length) return drag;
    this.on("mouseover.force", d3_layout_forceMouseover).on("mouseout.force", d3_layout_forceMouseout).call(drag);
  };
  function dragmove(d) {
    d.px = d3.event.x, d.py = d3.event.y;
    force.resume();
  }
  return d3.rebind(force, event, "on");
};
function d3_layout_forceDragstart(d) {
  d.fixed |= 2;
}
function d3_layout_forceDragend(d) {
  d.fixed &= ~6;
}
function d3_layout_forceMouseover(d) {
  d.fixed |= 4;
  d.px = d.x, d.py = d.y;
}
function d3_layout_forceMouseout(d) {
  d.fixed &= ~4;
}
function d3_layout_forceAccumulate(quad, alpha, charges) {
  var cx = 0, cy = 0;
  quad.charge = 0;
  if (!quad.leaf) {
    var nodes = quad.nodes, n = nodes.length, i = -1, c;
    while (++i < n) {
      c = nodes[i];
      if (c == null) continue;
      d3_layout_forceAccumulate(c, alpha, charges);
      quad.charge += c.charge;
      cx += c.charge * c.cx;
      cy += c.charge * c.cy;
    }
  }
  if (quad.point) {
    if (!quad.leaf) {
      quad.point.x += Math.random() - .5;
      quad.point.y += Math.random() - .5;
    }
    var k = alpha * charges[quad.point.index];
    quad.charge += quad.pointCharge = k;
    cx += k * quad.point.x;
    cy += k * quad.point.y;
  }
  quad.cx = cx / quad.charge;
  quad.cy = cy / quad.charge;
}
var d3_layout_forceLinkDistance = 20, d3_layout_forceLinkStrength = 1, d3_layout_forceChargeDistance2 = Infinity;
d3.layout.hierarchy = function() {
  var sort = d3_layout_hierarchySort, children = d3_layout_hierarchyChildren, value = d3_layout_hierarchyValue;
  function hierarchy(root) {
    var stack = [ root ], nodes = [], node;
    root.depth = 0;
    while ((node = stack.pop()) != null) {
      nodes.push(node);
      if ((childs = children.call(hierarchy, node, node.depth)) && (n = childs.length)) {
        var n, childs, child;
        while (--n >= 0) {
          stack.push(child = childs[n]);
          child.parent = node;
          child.depth = node.depth + 1;
        }
        if (value) node.value = 0;
        node.children = childs;
      } else {
        if (value) node.value = +value.call(hierarchy, node, node.depth) || 0;
        delete node.children;
      }
    }
    d3_layout_hierarchyVisitAfter(root, function(node) {
      var childs, parent;
      if (sort && (childs = node.children)) childs.sort(sort);
      if (value && (parent = node.parent)) parent.value += node.value;
    });
    return nodes;
  }
  hierarchy.sort = function(x) {
    if (!arguments.length) return sort;
    sort = x;
    return hierarchy;
  };
  hierarchy.children = function(x) {
    if (!arguments.length) return children;
    children = x;
    return hierarchy;
  };
  hierarchy.value = function(x) {
    if (!arguments.length) return value;
    value = x;
    return hierarchy;
  };
  hierarchy.revalue = function(root) {
    if (value) {
      d3_layout_hierarchyVisitBefore(root, function(node) {
        if (node.children) node.value = 0;
      });
      d3_layout_hierarchyVisitAfter(root, function(node) {
        var parent;
        if (!node.children) node.value = +value.call(hierarchy, node, node.depth) || 0;
        if (parent = node.parent) parent.value += node.value;
      });
    }
    return root;
  };
  return hierarchy;
};
function d3_layout_hierarchyRebind(object, hierarchy) {
  d3.rebind(object, hierarchy, "sort", "children", "value");
  object.nodes = object;
  object.links = d3_layout_hierarchyLinks;
  return object;
}
function d3_layout_hierarchyVisitBefore(node, callback) {
  var nodes = [ node ];
  while ((node = nodes.pop()) != null) {
    callback(node);
    if ((children = node.children) && (n = children.length)) {
      var n, children;
      while (--n >= 0) nodes.push(children[n]);
    }
  }
}
function d3_layout_hierarchyVisitAfter(node, callback) {
  var nodes = [ node ], nodes2 = [];
  while ((node = nodes.pop()) != null) {
    nodes2.push(node);
    if ((children = node.children) && (n = children.length)) {
      var i = -1, n, children;
      while (++i < n) nodes.push(children[i]);
    }
  }
  while ((node = nodes2.pop()) != null) {
    callback(node);
  }
}
function d3_layout_hierarchyChildren(d) {
  return d.children;
}
function d3_layout_hierarchyValue(d) {
  return d.value;
}
function d3_layout_hierarchySort(a, b) {
  return b.value - a.value;
}
function d3_layout_hierarchyLinks(nodes) {
  return d3.merge(nodes.map(function(parent) {
    return (parent.children || []).map(function(child) {
      return {
        source: parent,
        target: child
      };
    });
  }));
}
d3.layout.partition = function() {
  var hierarchy = d3.layout.hierarchy(), size = [ 1, 1 ];
  function position(node, x, dx, dy) {
    var children = node.children;
    node.x = x;
    node.y = node.depth * dy;
    node.dx = dx;
    node.dy = dy;
    if (children && (n = children.length)) {
      var i = -1, n, c, d;
      dx = node.value ? dx / node.value : 0;
      while (++i < n) {
        position(c = children[i], x, d = c.value * dx, dy);
        x += d;
      }
    }
  }
  function depth(node) {
    var children = node.children, d = 0;
    if (children && (n = children.length)) {
      var i = -1, n;
      while (++i < n) d = Math.max(d, depth(children[i]));
    }
    return 1 + d;
  }
  function partition(d, i) {
    var nodes = hierarchy.call(this, d, i);
    position(nodes[0], 0, size[0], size[1] / depth(nodes[0]));
    return nodes;
  }
  partition.size = function(x) {
    if (!arguments.length) return size;
    size = x;
    return partition;
  };
  return d3_layout_hierarchyRebind(partition, hierarchy);
};
d3.layout.pie = function() {
  var value = Number, sort = d3_layout_pieSortByValue, startAngle = 0, endAngle = τ, padAngle = 0;
  function pie(data) {
    var n = data.length, values = data.map(function(d, i) {
      return +value.call(pie, d, i);
    }), a = +(typeof startAngle === "function" ? startAngle.apply(this, arguments) : startAngle), da = (typeof endAngle === "function" ? endAngle.apply(this, arguments) : endAngle) - a, p = Math.min(Math.abs(da) / n, +(typeof padAngle === "function" ? padAngle.apply(this, arguments) : padAngle)), pa = p * (da < 0 ? -1 : 1), sum = d3.sum(values), k = sum ? (da - n * pa) / sum : 0, index = d3.range(n), arcs = [], v;
    if (sort != null) index.sort(sort === d3_layout_pieSortByValue ? function(i, j) {
      return values[j] - values[i];
    } : function(i, j) {
      return sort(data[i], data[j]);
    });
    index.forEach(function(i) {
      arcs[i] = {
        data: data[i],
        value: v = values[i],
        startAngle: a,
        endAngle: a += v * k + pa,
        padAngle: p
      };
    });
    return arcs;
  }
  pie.value = function(_) {
    if (!arguments.length) return value;
    value = _;
    return pie;
  };
  pie.sort = function(_) {
    if (!arguments.length) return sort;
    sort = _;
    return pie;
  };
  pie.startAngle = function(_) {
    if (!arguments.length) return startAngle;
    startAngle = _;
    return pie;
  };
  pie.endAngle = function(_) {
    if (!arguments.length) return endAngle;
    endAngle = _;
    return pie;
  };
  pie.padAngle = function(_) {
    if (!arguments.length) return padAngle;
    padAngle = _;
    return pie;
  };
  return pie;
};
var d3_layout_pieSortByValue = {};
d3.layout.stack = function() {
  var values = d3_identity, order = d3_layout_stackOrderDefault, offset = d3_layout_stackOffsetZero, out = d3_layout_stackOut, x = d3_layout_stackX, y = d3_layout_stackY;
  function stack(data, index) {
    if (!(n = data.length)) return data;
    var series = data.map(function(d, i) {
      return values.call(stack, d, i);
    });
    var points = series.map(function(d) {
      return d.map(function(v, i) {
        return [ x.call(stack, v, i), y.call(stack, v, i) ];
      });
    });
    var orders = order.call(stack, points, index);
    series = d3.permute(series, orders);
    points = d3.permute(points, orders);
    var offsets = offset.call(stack, points, index);
    var m = series[0].length, n, i, j, o;
    for (j = 0; j < m; ++j) {
      out.call(stack, series[0][j], o = offsets[j], points[0][j][1]);
      for (i = 1; i < n; ++i) {
        out.call(stack, series[i][j], o += points[i - 1][j][1], points[i][j][1]);
      }
    }
    return data;
  }
  stack.values = function(x) {
    if (!arguments.length) return values;
    values = x;
    return stack;
  };
  stack.order = function(x) {
    if (!arguments.length) return order;
    order = typeof x === "function" ? x : d3_layout_stackOrders.get(x) || d3_layout_stackOrderDefault;
    return stack;
  };
  stack.offset = function(x) {
    if (!arguments.length) return offset;
    offset = typeof x === "function" ? x : d3_layout_stackOffsets.get(x) || d3_layout_stackOffsetZero;
    return stack;
  };
  stack.x = function(z) {
    if (!arguments.length) return x;
    x = z;
    return stack;
  };
  stack.y = function(z) {
    if (!arguments.length) return y;
    y = z;
    return stack;
  };
  stack.out = function(z) {
    if (!arguments.length) return out;
    out = z;
    return stack;
  };
  return stack;
};
function d3_layout_stackX(d) {
  return d.x;
}
function d3_layout_stackY(d) {
  return d.y;
}
function d3_layout_stackOut(d, y0, y) {
  d.y0 = y0;
  d.y = y;
}
var d3_layout_stackOrders = d3.map({
  "inside-out": function(data) {
    var n = data.length, i, j, max = data.map(d3_layout_stackMaxIndex), sums = data.map(d3_layout_stackReduceSum), index = d3.range(n).sort(function(a, b) {
      return max[a] - max[b];
    }), top = 0, bottom = 0, tops = [], bottoms = [];
    for (i = 0; i < n; ++i) {
      j = index[i];
      if (top < bottom) {
        top += sums[j];
        tops.push(j);
      } else {
        bottom += sums[j];
        bottoms.push(j);
      }
    }
    return bottoms.reverse().concat(tops);
  },
  reverse: function(data) {
    return d3.range(data.length).reverse();
  },
  "default": d3_layout_stackOrderDefault
});
var d3_layout_stackOffsets = d3.map({
  silhouette: function(data) {
    var n = data.length, m = data[0].length, sums = [], max = 0, i, j, o, y0 = [];
    for (j = 0; j < m; ++j) {
      for (i = 0, o = 0; i < n; i++) o += data[i][j][1];
      if (o > max) max = o;
      sums.push(o);
    }
    for (j = 0; j < m; ++j) {
      y0[j] = (max - sums[j]) / 2;
    }
    return y0;
  },
  wiggle: function(data) {
    var n = data.length, x = data[0], m = x.length, i, j, k, s1, s2, s3, dx, o, o0, y0 = [];
    y0[0] = o = o0 = 0;
    for (j = 1; j < m; ++j) {
      for (i = 0, s1 = 0; i < n; ++i) s1 += data[i][j][1];
      for (i = 0, s2 = 0, dx = x[j][0] - x[j - 1][0]; i < n; ++i) {
        for (k = 0, s3 = (data[i][j][1] - data[i][j - 1][1]) / (2 * dx); k < i; ++k) {
          s3 += (data[k][j][1] - data[k][j - 1][1]) / dx;
        }
        s2 += s3 * data[i][j][1];
      }
      y0[j] = o -= s1 ? s2 / s1 * dx : 0;
      if (o < o0) o0 = o;
    }
    for (j = 0; j < m; ++j) y0[j] -= o0;
    return y0;
  },
  expand: function(data) {
    var n = data.length, m = data[0].length, k = 1 / n, i, j, o, y0 = [];
    for (j = 0; j < m; ++j) {
      for (i = 0, o = 0; i < n; i++) o += data[i][j][1];
      if (o) for (i = 0; i < n; i++) data[i][j][1] /= o; else for (i = 0; i < n; i++) data[i][j][1] = k;
    }
    for (j = 0; j < m; ++j) y0[j] = 0;
    return y0;
  },
  zero: d3_layout_stackOffsetZero
});
function d3_layout_stackOrderDefault(data) {
  return d3.range(data.length);
}
function d3_layout_stackOffsetZero(data) {
  var j = -1, m = data[0].length, y0 = [];
  while (++j < m) y0[j] = 0;
  return y0;
}
function d3_layout_stackMaxIndex(array) {
  var i = 1, j = 0, v = array[0][1], k, n = array.length;
  for (;i < n; ++i) {
    if ((k = array[i][1]) > v) {
      j = i;
      v = k;
    }
  }
  return j;
}
function d3_layout_stackReduceSum(d) {
  return d.reduce(d3_layout_stackSum, 0);
}
function d3_layout_stackSum(p, d) {
  return p + d[1];
}
d3.layout.histogram = function() {
  var frequency = true, valuer = Number, ranger = d3_layout_histogramRange, binner = d3_layout_histogramBinSturges;
  function histogram(data, i) {
    var bins = [], values = data.map(valuer, this), range = ranger.call(this, values, i), thresholds = binner.call(this, range, values, i), bin, i = -1, n = values.length, m = thresholds.length - 1, k = frequency ? 1 : 1 / n, x;
    while (++i < m) {
      bin = bins[i] = [];
      bin.dx = thresholds[i + 1] - (bin.x = thresholds[i]);
      bin.y = 0;
    }
    if (m > 0) {
      i = -1;
      while (++i < n) {
        x = values[i];
        if (x >= range[0] && x <= range[1]) {
          bin = bins[d3.bisect(thresholds, x, 1, m) - 1];
          bin.y += k;
          bin.push(data[i]);
        }
      }
    }
    return bins;
  }
  histogram.value = function(x) {
    if (!arguments.length) return valuer;
    valuer = x;
    return histogram;
  };
  histogram.range = function(x) {
    if (!arguments.length) return ranger;
    ranger = d3_functor(x);
    return histogram;
  };
  histogram.bins = function(x) {
    if (!arguments.length) return binner;
    binner = typeof x === "number" ? function(range) {
      return d3_layout_histogramBinFixed(range, x);
    } : d3_functor(x);
    return histogram;
  };
  histogram.frequency = function(x) {
    if (!arguments.length) return frequency;
    frequency = !!x;
    return histogram;
  };
  return histogram;
};
function d3_layout_histogramBinSturges(range, values) {
  return d3_layout_histogramBinFixed(range, Math.ceil(Math.log(values.length) / Math.LN2 + 1));
}
function d3_layout_histogramBinFixed(range, n) {
  var x = -1, b = +range[0], m = (range[1] - b) / n, f = [];
  while (++x <= n) f[x] = m * x + b;
  return f;
}
function d3_layout_histogramRange(values) {
  return [ d3.min(values), d3.max(values) ];
}
d3.layout.pack = function() {
  var hierarchy = d3.layout.hierarchy().sort(d3_layout_packSort), padding = 0, size = [ 1, 1 ], radius;
  function pack(d, i) {
    var nodes = hierarchy.call(this, d, i), root = nodes[0], w = size[0], h = size[1], r = radius == null ? Math.sqrt : typeof radius === "function" ? radius : function() {
      return radius;
    };
    root.x = root.y = 0;
    d3_layout_hierarchyVisitAfter(root, function(d) {
      d.r = +r(d.value);
    });
    d3_layout_hierarchyVisitAfter(root, d3_layout_packSiblings);
    if (padding) {
      var dr = padding * (radius ? 1 : Math.max(2 * root.r / w, 2 * root.r / h)) / 2;
      d3_layout_hierarchyVisitAfter(root, function(d) {
        d.r += dr;
      });
      d3_layout_hierarchyVisitAfter(root, d3_layout_packSiblings);
      d3_layout_hierarchyVisitAfter(root, function(d) {
        d.r -= dr;
      });
    }
    d3_layout_packTransform(root, w / 2, h / 2, radius ? 1 : 1 / Math.max(2 * root.r / w, 2 * root.r / h));
    return nodes;
  }
  pack.size = function(_) {
    if (!arguments.length) return size;
    size = _;
    return pack;
  };
  pack.radius = function(_) {
    if (!arguments.length) return radius;
    radius = _ == null || typeof _ === "function" ? _ : +_;
    return pack;
  };
  pack.padding = function(_) {
    if (!arguments.length) return padding;
    padding = +_;
    return pack;
  };
  return d3_layout_hierarchyRebind(pack, hierarchy);
};
function d3_layout_packSort(a, b) {
  return a.value - b.value;
}
function d3_layout_packInsert(a, b) {
  var c = a._pack_next;
  a._pack_next = b;
  b._pack_prev = a;
  b._pack_next = c;
  c._pack_prev = b;
}
function d3_layout_packSplice(a, b) {
  a._pack_next = b;
  b._pack_prev = a;
}
function d3_layout_packIntersects(a, b) {
  var dx = b.x - a.x, dy = b.y - a.y, dr = a.r + b.r;
  return .999 * dr * dr > dx * dx + dy * dy;
}
function d3_layout_packSiblings(node) {
  if (!(nodes = node.children) || !(n = nodes.length)) return;
  var nodes, xMin = Infinity, xMax = -Infinity, yMin = Infinity, yMax = -Infinity, a, b, c, i, j, k, n;
  function bound(node) {
    xMin = Math.min(node.x - node.r, xMin);
    xMax = Math.max(node.x + node.r, xMax);
    yMin = Math.min(node.y - node.r, yMin);
    yMax = Math.max(node.y + node.r, yMax);
  }
  nodes.forEach(d3_layout_packLink);
  a = nodes[0];
  a.x = -a.r;
  a.y = 0;
  bound(a);
  if (n > 1) {
    b = nodes[1];
    b.x = b.r;
    b.y = 0;
    bound(b);
    if (n > 2) {
      c = nodes[2];
      d3_layout_packPlace(a, b, c);
      bound(c);
      d3_layout_packInsert(a, c);
      a._pack_prev = c;
      d3_layout_packInsert(c, b);
      b = a._pack_next;
      for (i = 3; i < n; i++) {
        d3_layout_packPlace(a, b, c = nodes[i]);
        var isect = 0, s1 = 1, s2 = 1;
        for (j = b._pack_next; j !== b; j = j._pack_next, s1++) {
          if (d3_layout_packIntersects(j, c)) {
            isect = 1;
            break;
          }
        }
        if (isect == 1) {
          for (k = a._pack_prev; k !== j._pack_prev; k = k._pack_prev, s2++) {
            if (d3_layout_packIntersects(k, c)) {
              break;
            }
          }
        }
        if (isect) {
          if (s1 < s2 || s1 == s2 && b.r < a.r) d3_layout_packSplice(a, b = j); else d3_layout_packSplice(a = k, b);
          i--;
        } else {
          d3_layout_packInsert(a, c);
          b = c;
          bound(c);
        }
      }
    }
  }
  var cx = (xMin + xMax) / 2, cy = (yMin + yMax) / 2, cr = 0;
  for (i = 0; i < n; i++) {
    c = nodes[i];
    c.x -= cx;
    c.y -= cy;
    cr = Math.max(cr, c.r + Math.sqrt(c.x * c.x + c.y * c.y));
  }
  node.r = cr;
  nodes.forEach(d3_layout_packUnlink);
}
function d3_layout_packLink(node) {
  node._pack_next = node._pack_prev = node;
}
function d3_layout_packUnlink(node) {
  delete node._pack_next;
  delete node._pack_prev;
}
function d3_layout_packTransform(node, x, y, k) {
  var children = node.children;
  node.x = x += k * node.x;
  node.y = y += k * node.y;
  node.r *= k;
  if (children) {
    var i = -1, n = children.length;
    while (++i < n) d3_layout_packTransform(children[i], x, y, k);
  }
}
function d3_layout_packPlace(a, b, c) {
  var db = a.r + c.r, dx = b.x - a.x, dy = b.y - a.y;
  if (db && (dx || dy)) {
    var da = b.r + c.r, dc = dx * dx + dy * dy;
    da *= da;
    db *= db;
    var x = .5 + (db - da) / (2 * dc), y = Math.sqrt(Math.max(0, 2 * da * (db + dc) - (db -= dc) * db - da * da)) / (2 * dc);
    c.x = a.x + x * dx + y * dy;
    c.y = a.y + x * dy - y * dx;
  } else {
    c.x = a.x + db;
    c.y = a.y;
  }
}
d3.layout.tree = function() {
  var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [ 1, 1 ], nodeSize = null;
  function tree(d, i) {
    var nodes = hierarchy.call(this, d, i), root0 = nodes[0], root1 = wrapTree(root0);
    d3_layout_hierarchyVisitAfter(root1, firstWalk), root1.parent.m = -root1.z;
    d3_layout_hierarchyVisitBefore(root1, secondWalk);
    if (nodeSize) d3_layout_hierarchyVisitBefore(root0, sizeNode); else {
      var left = root0, right = root0, bottom = root0;
      d3_layout_hierarchyVisitBefore(root0, function(node) {
        if (node.x < left.x) left = node;
        if (node.x > right.x) right = node;
        if (node.depth > bottom.depth) bottom = node;
      });
      var tx = separation(left, right) / 2 - left.x, kx = size[0] / (right.x + separation(right, left) / 2 + tx), ky = size[1] / (bottom.depth || 1);
      d3_layout_hierarchyVisitBefore(root0, function(node) {
        node.x = (node.x + tx) * kx;
        node.y = node.depth * ky;
      });
    }
    return nodes;
  }
  function wrapTree(root0) {
    var root1 = {
      A: null,
      children: [ root0 ]
    }, queue = [ root1 ], node1;
    while ((node1 = queue.pop()) != null) {
      for (var children = node1.children, child, i = 0, n = children.length; i < n; ++i) {
        queue.push((children[i] = child = {
          _: children[i],
          parent: node1,
          children: (child = children[i].children) && child.slice() || [],
          A: null,
          a: null,
          z: 0,
          m: 0,
          c: 0,
          s: 0,
          t: null,
          i: i
        }).a = child);
      }
    }
    return root1.children[0];
  }
  function firstWalk(v) {
    var children = v.children, siblings = v.parent.children, w = v.i ? siblings[v.i - 1] : null;
    if (children.length) {
      d3_layout_treeShift(v);
      var midpoint = (children[0].z + children[children.length - 1].z) / 2;
      if (w) {
        v.z = w.z + separation(v._, w._);
        v.m = v.z - midpoint;
      } else {
        v.z = midpoint;
      }
    } else if (w) {
      v.z = w.z + separation(v._, w._);
    }
    v.parent.A = apportion(v, w, v.parent.A || siblings[0]);
  }
  function secondWalk(v) {
    v._.x = v.z + v.parent.m;
    v.m += v.parent.m;
  }
  function apportion(v, w, ancestor) {
    if (w) {
      var vip = v, vop = v, vim = w, vom = vip.parent.children[0], sip = vip.m, sop = vop.m, sim = vim.m, som = vom.m, shift;
      while (vim = d3_layout_treeRight(vim), vip = d3_layout_treeLeft(vip), vim && vip) {
        vom = d3_layout_treeLeft(vom);
        vop = d3_layout_treeRight(vop);
        vop.a = v;
        shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);
        if (shift > 0) {
          d3_layout_treeMove(d3_layout_treeAncestor(vim, v, ancestor), v, shift);
          sip += shift;
          sop += shift;
        }
        sim += vim.m;
        sip += vip.m;
        som += vom.m;
        sop += vop.m;
      }
      if (vim && !d3_layout_treeRight(vop)) {
        vop.t = vim;
        vop.m += sim - sop;
      }
      if (vip && !d3_layout_treeLeft(vom)) {
        vom.t = vip;
        vom.m += sip - som;
        ancestor = v;
      }
    }
    return ancestor;
  }
  function sizeNode(node) {
    node.x *= size[0];
    node.y = node.depth * size[1];
  }
  tree.separation = function(x) {
    if (!arguments.length) return separation;
    separation = x;
    return tree;
  };
  tree.size = function(x) {
    if (!arguments.length) return nodeSize ? null : size;
    nodeSize = (size = x) == null ? sizeNode : null;
    return tree;
  };
  tree.nodeSize = function(x) {
    if (!arguments.length) return nodeSize ? size : null;
    nodeSize = (size = x) == null ? null : sizeNode;
    return tree;
  };
  return d3_layout_hierarchyRebind(tree, hierarchy);
};
function d3_layout_treeSeparation(a, b) {
  return a.parent == b.parent ? 1 : 2;
}
function d3_layout_treeLeft(v) {
  var children = v.children;
  return children.length ? children[0] : v.t;
}
function d3_layout_treeRight(v) {
  var children = v.children, n;
  return (n = children.length) ? children[n - 1] : v.t;
}
function d3_layout_treeMove(wm, wp, shift) {
  var change = shift / (wp.i - wm.i);
  wp.c -= change;
  wp.s += shift;
  wm.c += change;
  wp.z += shift;
  wp.m += shift;
}
function d3_layout_treeShift(v) {
  var shift = 0, change = 0, children = v.children, i = children.length, w;
  while (--i >= 0) {
    w = children[i];
    w.z += shift;
    w.m += shift;
    shift += w.s + (change += w.c);
  }
}
function d3_layout_treeAncestor(vim, v, ancestor) {
  return vim.a.parent === v.parent ? vim.a : ancestor;
}
d3.layout.cluster = function() {
  var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [ 1, 1 ], nodeSize = false;
  function cluster(d, i) {
    var nodes = hierarchy.call(this, d, i), root = nodes[0], previousNode, x = 0;
    d3_layout_hierarchyVisitAfter(root, function(node) {
      var children = node.children;
      if (children && children.length) {
        node.x = d3_layout_clusterX(children);
        node.y = d3_layout_clusterY(children);
      } else {
        node.x = previousNode ? x += separation(node, previousNode) : 0;
        node.y = 0;
        previousNode = node;
      }
    });
    var left = d3_layout_clusterLeft(root), right = d3_layout_clusterRight(root), x0 = left.x - separation(left, right) / 2, x1 = right.x + separation(right, left) / 2;
    d3_layout_hierarchyVisitAfter(root, nodeSize ? function(node) {
      node.x = (node.x - root.x) * size[0];
      node.y = (root.y - node.y) * size[1];
    } : function(node) {
      node.x = (node.x - x0) / (x1 - x0) * size[0];
      node.y = (1 - (root.y ? node.y / root.y : 1)) * size[1];
    });
    return nodes;
  }
  cluster.separation = function(x) {
    if (!arguments.length) return separation;
    separation = x;
    return cluster;
  };
  cluster.size = function(x) {
    if (!arguments.length) return nodeSize ? null : size;
    nodeSize = (size = x) == null;
    return cluster;
  };
  cluster.nodeSize = function(x) {
    if (!arguments.length) return nodeSize ? size : null;
    nodeSize = (size = x) != null;
    return cluster;
  };
  return d3_layout_hierarchyRebind(cluster, hierarchy);
};
function d3_layout_clusterY(children) {
  return 1 + d3.max(children, function(child) {
    return child.y;
  });
}
function d3_layout_clusterX(children) {
  return children.reduce(function(x, child) {
    return x + child.x;
  }, 0) / children.length;
}
function d3_layout_clusterLeft(node) {
  var children = node.children;
  return children && children.length ? d3_layout_clusterLeft(children[0]) : node;
}
function d3_layout_clusterRight(node) {
  var children = node.children, n;
  return children && (n = children.length) ? d3_layout_clusterRight(children[n - 1]) : node;
}
d3.layout.treemap = function() {
  var hierarchy = d3.layout.hierarchy(), round = Math.round, size = [ 1, 1 ], padding = null, pad = d3_layout_treemapPadNull, sticky = false, stickies, mode = "squarify", ratio = .5 * (1 + Math.sqrt(5));
  function scale(children, k) {
    var i = -1, n = children.length, child, area;
    while (++i < n) {
      area = (child = children[i]).value * (k < 0 ? 0 : k);
      child.area = isNaN(area) || area <= 0 ? 0 : area;
    }
  }
  function squarify(node) {
    var children = node.children;
    if (children && children.length) {
      var rect = pad(node), row = [], remaining = children.slice(), child, best = Infinity, score, u = mode === "slice" ? rect.dx : mode === "dice" ? rect.dy : mode === "slice-dice" ? node.depth & 1 ? rect.dy : rect.dx : Math.min(rect.dx, rect.dy), n;
      scale(remaining, rect.dx * rect.dy / node.value);
      row.area = 0;
      while ((n = remaining.length) > 0) {
        row.push(child = remaining[n - 1]);
        row.area += child.area;
        if (mode !== "squarify" || (score = worst(row, u)) <= best) {
          remaining.pop();
          best = score;
        } else {
          row.area -= row.pop().area;
          position(row, u, rect, false);
          u = Math.min(rect.dx, rect.dy);
          row.length = row.area = 0;
          best = Infinity;
        }
      }
      if (row.length) {
        position(row, u, rect, true);
        row.length = row.area = 0;
      }
      children.forEach(squarify);
    }
  }
  function stickify(node) {
    var children = node.children;
    if (children && children.length) {
      var rect = pad(node), remaining = children.slice(), child, row = [];
      scale(remaining, rect.dx * rect.dy / node.value);
      row.area = 0;
      while (child = remaining.pop()) {
        row.push(child);
        row.area += child.area;
        if (child.z != null) {
          position(row, child.z ? rect.dx : rect.dy, rect, !remaining.length);
          row.length = row.area = 0;
        }
      }
      children.forEach(stickify);
    }
  }
  function worst(row, u) {
    var s = row.area, r, rmax = 0, rmin = Infinity, i = -1, n = row.length;
    while (++i < n) {
      if (!(r = row[i].area)) continue;
      if (r < rmin) rmin = r;
      if (r > rmax) rmax = r;
    }
    s *= s;
    u *= u;
    return s ? Math.max(u * rmax * ratio / s, s / (u * rmin * ratio)) : Infinity;
  }
  function position(row, u, rect, flush) {
    var i = -1, n = row.length, x = rect.x, y = rect.y, v = u ? round(row.area / u) : 0, o;
    if (u == rect.dx) {
      if (flush || v > rect.dy) v = rect.dy;
      while (++i < n) {
        o = row[i];
        o.x = x;
        o.y = y;
        o.dy = v;
        x += o.dx = Math.min(rect.x + rect.dx - x, v ? round(o.area / v) : 0);
      }
      o.z = true;
      o.dx += rect.x + rect.dx - x;
      rect.y += v;
      rect.dy -= v;
    } else {
      if (flush || v > rect.dx) v = rect.dx;
      while (++i < n) {
        o = row[i];
        o.x = x;
        o.y = y;
        o.dx = v;
        y += o.dy = Math.min(rect.y + rect.dy - y, v ? round(o.area / v) : 0);
      }
      o.z = false;
      o.dy += rect.y + rect.dy - y;
      rect.x += v;
      rect.dx -= v;
    }
  }
  function treemap(d) {
    var nodes = stickies || hierarchy(d), root = nodes[0];
    root.x = root.y = 0;
    if (root.value) root.dx = size[0], root.dy = size[1]; else root.dx = root.dy = 0;
    if (stickies) hierarchy.revalue(root);
    scale([ root ], root.dx * root.dy / root.value);
    (stickies ? stickify : squarify)(root);
    if (sticky) stickies = nodes;
    return nodes;
  }
  treemap.size = function(x) {
    if (!arguments.length) return size;
    size = x;
    return treemap;
  };
  treemap.padding = function(x) {
    if (!arguments.length) return padding;
    function padFunction(node) {
      var p = x.call(treemap, node, node.depth);
      return p == null ? d3_layout_treemapPadNull(node) : d3_layout_treemapPad(node, typeof p === "number" ? [ p, p, p, p ] : p);
    }
    function padConstant(node) {
      return d3_layout_treemapPad(node, x);
    }
    var type;
    pad = (padding = x) == null ? d3_layout_treemapPadNull : (type = typeof x) === "function" ? padFunction : type === "number" ? (x = [ x, x, x, x ], 
    padConstant) : padConstant;
    return treemap;
  };
  treemap.round = function(x) {
    if (!arguments.length) return round != Number;
    round = x ? Math.round : Number;
    return treemap;
  };
  treemap.sticky = function(x) {
    if (!arguments.length) return sticky;
    sticky = x;
    stickies = null;
    return treemap;
  };
  treemap.ratio = function(x) {
    if (!arguments.length) return ratio;
    ratio = x;
    return treemap;
  };
  treemap.mode = function(x) {
    if (!arguments.length) return mode;
    mode = x + "";
    return treemap;
  };
  return d3_layout_hierarchyRebind(treemap, hierarchy);
};
function d3_layout_treemapPadNull(node) {
  return {
    x: node.x,
    y: node.y,
    dx: node.dx,
    dy: node.dy
  };
}
function d3_layout_treemapPad(node, padding) {
  var x = node.x + padding[3], y = node.y + padding[0], dx = node.dx - padding[1] - padding[3], dy = node.dy - padding[0] - padding[2];
  if (dx < 0) {
    x += dx / 2;
    dx = 0;
  }
  if (dy < 0) {
    y += dy / 2;
    dy = 0;
  }
  return {
    x: x,
    y: y,
    dx: dx,
    dy: dy
  };
}
d3.random = {
  normal: function(µ, σ) {
    var n = arguments.length;
    if (n < 2) σ = 1;
    if (n < 1) µ = 0;
    return function() {
      var x, y, r;
      do {
        x = Math.random() * 2 - 1;
        y = Math.random() * 2 - 1;
        r = x * x + y * y;
      } while (!r || r > 1);
      return µ + σ * x * Math.sqrt(-2 * Math.log(r) / r);
    };
  },
  logNormal: function() {
    var random = d3.random.normal.apply(d3, arguments);
    return function() {
      return Math.exp(random());
    };
  },
  bates: function(m) {
    var random = d3.random.irwinHall(m);
    return function() {
      return random() / m;
    };
  },
  irwinHall: function(m) {
    return function() {
      for (var s = 0, j = 0; j < m; j++) s += Math.random();
      return s;
    };
  }
};
d3.scale = {};
function d3_scaleExtent(domain) {
  var start = domain[0], stop = domain[domain.length - 1];
  return start < stop ? [ start, stop ] : [ stop, start ];
}
function d3_scaleRange(scale) {
  return scale.rangeExtent ? scale.rangeExtent() : d3_scaleExtent(scale.range());
}
function d3_scale_bilinear(domain, range, uninterpolate, interpolate) {
  var u = uninterpolate(domain[0], domain[1]), i = interpolate(range[0], range[1]);
  return function(x) {
    return i(u(x));
  };
}
function d3_scale_nice(domain, nice) {
  var i0 = 0, i1 = domain.length - 1, x0 = domain[i0], x1 = domain[i1], dx;
  if (x1 < x0) {
    dx = i0, i0 = i1, i1 = dx;
    dx = x0, x0 = x1, x1 = dx;
  }
  domain[i0] = nice.floor(x0);
  domain[i1] = nice.ceil(x1);
  return domain;
}
function d3_scale_niceStep(step) {
  return step ? {
    floor: function(x) {
      return Math.floor(x / step) * step;
    },
    ceil: function(x) {
      return Math.ceil(x / step) * step;
    }
  } : d3_scale_niceIdentity;
}
var d3_scale_niceIdentity = {
  floor: d3_identity,
  ceil: d3_identity
};
function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
  var u = [], i = [], j = 0, k = Math.min(domain.length, range.length) - 1;
  if (domain[k] < domain[0]) {
    domain = domain.slice().reverse();
    range = range.slice().reverse();
  }
  while (++j <= k) {
    u.push(uninterpolate(domain[j - 1], domain[j]));
    i.push(interpolate(range[j - 1], range[j]));
  }
  return function(x) {
    var j = d3.bisect(domain, x, 1, k) - 1;
    return i[j](u[j](x));
  };
}
d3.scale.linear = function() {
  return d3_scale_linear([ 0, 1 ], [ 0, 1 ], d3_interpolate, false);
};
function d3_scale_linear(domain, range, interpolate, clamp) {
  var output, input;
  function rescale() {
    var linear = Math.min(domain.length, range.length) > 2 ? d3_scale_polylinear : d3_scale_bilinear, uninterpolate = clamp ? d3_uninterpolateClamp : d3_uninterpolateNumber;
    output = linear(domain, range, uninterpolate, interpolate);
    input = linear(range, domain, uninterpolate, d3_interpolate);
    return scale;
  }
  function scale(x) {
    return output(x);
  }
  scale.invert = function(y) {
    return input(y);
  };
  scale.domain = function(x) {
    if (!arguments.length) return domain;
    domain = x.map(Number);
    return rescale();
  };
  scale.range = function(x) {
    if (!arguments.length) return range;
    range = x;
    return rescale();
  };
  scale.rangeRound = function(x) {
    return scale.range(x).interpolate(d3_interpolateRound);
  };
  scale.clamp = function(x) {
    if (!arguments.length) return clamp;
    clamp = x;
    return rescale();
  };
  scale.interpolate = function(x) {
    if (!arguments.length) return interpolate;
    interpolate = x;
    return rescale();
  };
  scale.ticks = function(m) {
    return d3_scale_linearTicks(domain, m);
  };
  scale.tickFormat = function(m, format) {
    return d3_scale_linearTickFormat(domain, m, format);
  };
  scale.nice = function(m) {
    d3_scale_linearNice(domain, m);
    return rescale();
  };
  scale.copy = function() {
    return d3_scale_linear(domain, range, interpolate, clamp);
  };
  return rescale();
}
function d3_scale_linearRebind(scale, linear) {
  return d3.rebind(scale, linear, "range", "rangeRound", "interpolate", "clamp");
}
function d3_scale_linearNice(domain, m) {
  d3_scale_nice(domain, d3_scale_niceStep(d3_scale_linearTickRange(domain, m)[2]));
  d3_scale_nice(domain, d3_scale_niceStep(d3_scale_linearTickRange(domain, m)[2]));
  return domain;
}
function d3_scale_linearTickRange(domain, m) {
  if (m == null) m = 10;
  var extent = d3_scaleExtent(domain), span = extent[1] - extent[0], step = Math.pow(10, Math.floor(Math.log(span / m) / Math.LN10)), err = m / span * step;
  if (err <= .15) step *= 10; else if (err <= .35) step *= 5; else if (err <= .75) step *= 2;
  extent[0] = Math.ceil(extent[0] / step) * step;
  extent[1] = Math.floor(extent[1] / step) * step + step * .5;
  extent[2] = step;
  return extent;
}
function d3_scale_linearTicks(domain, m) {
  return d3.range.apply(d3, d3_scale_linearTickRange(domain, m));
}
function d3_scale_linearTickFormat(domain, m, format) {
  var range = d3_scale_linearTickRange(domain, m);
  if (format) {
    var match = d3_format_re.exec(format);
    match.shift();
    if (match[8] === "s") {
      var prefix = d3.formatPrefix(Math.max(abs(range[0]), abs(range[1])));
      if (!match[7]) match[7] = "." + d3_scale_linearPrecision(prefix.scale(range[2]));
      match[8] = "f";
      format = d3.format(match.join(""));
      return function(d) {
        return format(prefix.scale(d)) + prefix.symbol;
      };
    }
    if (!match[7]) match[7] = "." + d3_scale_linearFormatPrecision(match[8], range);
    format = match.join("");
  } else {
    format = ",." + d3_scale_linearPrecision(range[2]) + "f";
  }
  return d3.format(format);
}
var d3_scale_linearFormatSignificant = {
  s: 1,
  g: 1,
  p: 1,
  r: 1,
  e: 1
};
function d3_scale_linearPrecision(value) {
  return -Math.floor(Math.log(value) / Math.LN10 + .01);
}
function d3_scale_linearFormatPrecision(type, range) {
  var p = d3_scale_linearPrecision(range[2]);
  return type in d3_scale_linearFormatSignificant ? Math.abs(p - d3_scale_linearPrecision(Math.max(abs(range[0]), abs(range[1])))) + +(type !== "e") : p - (type === "%") * 2;
}
d3.scale.log = function() {
  return d3_scale_log(d3.scale.linear().domain([ 0, 1 ]), 10, true, [ 1, 10 ]);
};
function d3_scale_log(linear, base, positive, domain) {
  function log(x) {
    return (positive ? Math.log(x < 0 ? 0 : x) : -Math.log(x > 0 ? 0 : -x)) / Math.log(base);
  }
  function pow(x) {
    return positive ? Math.pow(base, x) : -Math.pow(base, -x);
  }
  function scale(x) {
    return linear(log(x));
  }
  scale.invert = function(x) {
    return pow(linear.invert(x));
  };
  scale.domain = function(x) {
    if (!arguments.length) return domain;
    positive = x[0] >= 0;
    linear.domain((domain = x.map(Number)).map(log));
    return scale;
  };
  scale.base = function(_) {
    if (!arguments.length) return base;
    base = +_;
    linear.domain(domain.map(log));
    return scale;
  };
  scale.nice = function() {
    var niced = d3_scale_nice(domain.map(log), positive ? Math : d3_scale_logNiceNegative);
    linear.domain(niced);
    domain = niced.map(pow);
    return scale;
  };
  scale.ticks = function() {
    var extent = d3_scaleExtent(domain), ticks = [], u = extent[0], v = extent[1], i = Math.floor(log(u)), j = Math.ceil(log(v)), n = base % 1 ? 2 : base;
    if (isFinite(j - i)) {
      if (positive) {
        for (;i < j; i++) for (var k = 1; k < n; k++) ticks.push(pow(i) * k);
        ticks.push(pow(i));
      } else {
        ticks.push(pow(i));
        for (;i++ < j; ) for (var k = n - 1; k > 0; k--) ticks.push(pow(i) * k);
      }
      for (i = 0; ticks[i] < u; i++) {}
      for (j = ticks.length; ticks[j - 1] > v; j--) {}
      ticks = ticks.slice(i, j);
    }
    return ticks;
  };
  scale.tickFormat = function(n, format) {
    if (!arguments.length) return d3_scale_logFormat;
    if (arguments.length < 2) format = d3_scale_logFormat; else if (typeof format !== "function") format = d3.format(format);
    var k = Math.max(1, base * n / scale.ticks().length);
    return function(d) {
      var i = d / pow(Math.round(log(d)));
      if (i * base < base - .5) i *= base;
      return i <= k ? format(d) : "";
    };
  };
  scale.copy = function() {
    return d3_scale_log(linear.copy(), base, positive, domain);
  };
  return d3_scale_linearRebind(scale, linear);
}
var d3_scale_logFormat = d3.format(".0e"), d3_scale_logNiceNegative = {
  floor: function(x) {
    return -Math.ceil(-x);
  },
  ceil: function(x) {
    return -Math.floor(-x);
  }
};
d3.scale.pow = function() {
  return d3_scale_pow(d3.scale.linear(), 1, [ 0, 1 ]);
};
function d3_scale_pow(linear, exponent, domain) {
  var powp = d3_scale_powPow(exponent), powb = d3_scale_powPow(1 / exponent);
  function scale(x) {
    return linear(powp(x));
  }
  scale.invert = function(x) {
    return powb(linear.invert(x));
  };
  scale.domain = function(x) {
    if (!arguments.length) return domain;
    linear.domain((domain = x.map(Number)).map(powp));
    return scale;
  };
  scale.ticks = function(m) {
    return d3_scale_linearTicks(domain, m);
  };
  scale.tickFormat = function(m, format) {
    return d3_scale_linearTickFormat(domain, m, format);
  };
  scale.nice = function(m) {
    return scale.domain(d3_scale_linearNice(domain, m));
  };
  scale.exponent = function(x) {
    if (!arguments.length) return exponent;
    powp = d3_scale_powPow(exponent = x);
    powb = d3_scale_powPow(1 / exponent);
    linear.domain(domain.map(powp));
    return scale;
  };
  scale.copy = function() {
    return d3_scale_pow(linear.copy(), exponent, domain);
  };
  return d3_scale_linearRebind(scale, linear);
}
function d3_scale_powPow(e) {
  return function(x) {
    return x < 0 ? -Math.pow(-x, e) : Math.pow(x, e);
  };
}
d3.scale.sqrt = function() {
  return d3.scale.pow().exponent(.5);
};
d3.scale.ordinal = function() {
  return d3_scale_ordinal([], {
    t: "range",
    a: [ [] ]
  });
};
function d3_scale_ordinal(domain, ranger) {
  var index, range, rangeBand;
  function scale(x) {
    return range[((index.get(x) || (ranger.t === "range" ? index.set(x, domain.push(x)) : NaN)) - 1) % range.length];
  }
  function steps(start, step) {
    return d3.range(domain.length).map(function(i) {
      return start + step * i;
    });
  }
  scale.domain = function(x) {
    if (!arguments.length) return domain;
    domain = [];
    index = new d3_Map();
    var i = -1, n = x.length, xi;
    while (++i < n) if (!index.has(xi = x[i])) index.set(xi, domain.push(xi));
    return scale[ranger.t].apply(scale, ranger.a);
  };
  scale.range = function(x) {
    if (!arguments.length) return range;
    range = x;
    rangeBand = 0;
    ranger = {
      t: "range",
      a: arguments
    };
    return scale;
  };
  scale.rangePoints = function(x, padding) {
    if (arguments.length < 2) padding = 0;
    var start = x[0], stop = x[1], step = domain.length < 2 ? (start = (start + stop) / 2, 
    0) : (stop - start) / (domain.length - 1 + padding);
    range = steps(start + step * padding / 2, step);
    rangeBand = 0;
    ranger = {
      t: "rangePoints",
      a: arguments
    };
    return scale;
  };
  scale.rangeRoundPoints = function(x, padding) {
    if (arguments.length < 2) padding = 0;
    var start = x[0], stop = x[1], step = domain.length < 2 ? (start = stop = Math.round((start + stop) / 2), 
    0) : (stop - start) / (domain.length - 1 + padding) | 0;
    range = steps(start + Math.round(step * padding / 2 + (stop - start - (domain.length - 1 + padding) * step) / 2), step);
    rangeBand = 0;
    ranger = {
      t: "rangeRoundPoints",
      a: arguments
    };
    return scale;
  };
  scale.rangeBands = function(x, padding, outerPadding) {
    if (arguments.length < 2) padding = 0;
    if (arguments.length < 3) outerPadding = padding;
    var reverse = x[1] < x[0], start = x[reverse - 0], stop = x[1 - reverse], step = (stop - start) / (domain.length - padding + 2 * outerPadding);
    range = steps(start + step * outerPadding, step);
    if (reverse) range.reverse();
    rangeBand = step * (1 - padding);
    ranger = {
      t: "rangeBands",
      a: arguments
    };
    return scale;
  };
  scale.rangeRoundBands = function(x, padding, outerPadding) {
    if (arguments.length < 2) padding = 0;
    if (arguments.length < 3) outerPadding = padding;
    var reverse = x[1] < x[0], start = x[reverse - 0], stop = x[1 - reverse], step = Math.floor((stop - start) / (domain.length - padding + 2 * outerPadding));
    range = steps(start + Math.round((stop - start - (domain.length - padding) * step) / 2), step);
    if (reverse) range.reverse();
    rangeBand = Math.round(step * (1 - padding));
    ranger = {
      t: "rangeRoundBands",
      a: arguments
    };
    return scale;
  };
  scale.rangeBand = function() {
    return rangeBand;
  };
  scale.rangeExtent = function() {
    return d3_scaleExtent(ranger.a[0]);
  };
  scale.copy = function() {
    return d3_scale_ordinal(domain, ranger);
  };
  return scale.domain(domain);
}
d3.scale.category10 = function() {
  return d3.scale.ordinal().range(d3_category10);
};
d3.scale.category20 = function() {
  return d3.scale.ordinal().range(d3_category20);
};
d3.scale.category20b = function() {
  return d3.scale.ordinal().range(d3_category20b);
};
d3.scale.category20c = function() {
  return d3.scale.ordinal().range(d3_category20c);
};
var d3_category10 = [ 2062260, 16744206, 2924588, 14034728, 9725885, 9197131, 14907330, 8355711, 12369186, 1556175 ].map(d3_rgbString);
var d3_category20 = [ 2062260, 11454440, 16744206, 16759672, 2924588, 10018698, 14034728, 16750742, 9725885, 12955861, 9197131, 12885140, 14907330, 16234194, 8355711, 13092807, 12369186, 14408589, 1556175, 10410725 ].map(d3_rgbString);
var d3_category20b = [ 3750777, 5395619, 7040719, 10264286, 6519097, 9216594, 11915115, 13556636, 9202993, 12426809, 15186514, 15190932, 8666169, 11356490, 14049643, 15177372, 8077683, 10834324, 13528509, 14589654 ].map(d3_rgbString);
var d3_category20c = [ 3244733, 7057110, 10406625, 13032431, 15095053, 16616764, 16625259, 16634018, 3253076, 7652470, 10607003, 13101504, 7695281, 10394312, 12369372, 14342891, 6513507, 9868950, 12434877, 14277081 ].map(d3_rgbString);
d3.scale.quantile = function() {
  return d3_scale_quantile([], []);
};
function d3_scale_quantile(domain, range) {
  var thresholds;
  function rescale() {
    var k = 0, q = range.length;
    thresholds = [];
    while (++k < q) thresholds[k - 1] = d3.quantile(domain, k / q);
    return scale;
  }
  function scale(x) {
    if (!isNaN(x = +x)) return range[d3.bisect(thresholds, x)];
  }
  scale.domain = function(x) {
    if (!arguments.length) return domain;
    domain = x.map(d3_number).filter(d3_numeric).sort(d3_ascending);
    return rescale();
  };
  scale.range = function(x) {
    if (!arguments.length) return range;
    range = x;
    return rescale();
  };
  scale.quantiles = function() {
    return thresholds;
  };
  scale.invertExtent = function(y) {
    y = range.indexOf(y);
    return y < 0 ? [ NaN, NaN ] : [ y > 0 ? thresholds[y - 1] : domain[0], y < thresholds.length ? thresholds[y] : domain[domain.length - 1] ];
  };
  scale.copy = function() {
    return d3_scale_quantile(domain, range);
  };
  return rescale();
}
d3.scale.quantize = function() {
  return d3_scale_quantize(0, 1, [ 0, 1 ]);
};
function d3_scale_quantize(x0, x1, range) {
  var kx, i;
  function scale(x) {
    return range[Math.max(0, Math.min(i, Math.floor(kx * (x - x0))))];
  }
  function rescale() {
    kx = range.length / (x1 - x0);
    i = range.length - 1;
    return scale;
  }
  scale.domain = function(x) {
    if (!arguments.length) return [ x0, x1 ];
    x0 = +x[0];
    x1 = +x[x.length - 1];
    return rescale();
  };
  scale.range = function(x) {
    if (!arguments.length) return range;
    range = x;
    return rescale();
  };
  scale.invertExtent = function(y) {
    y = range.indexOf(y);
    y = y < 0 ? NaN : y / kx + x0;
    return [ y, y + 1 / kx ];
  };
  scale.copy = function() {
    return d3_scale_quantize(x0, x1, range);
  };
  return rescale();
}
d3.scale.threshold = function() {
  return d3_scale_threshold([ .5 ], [ 0, 1 ]);
};
function d3_scale_threshold(domain, range) {
  function scale(x) {
    if (x <= x) return range[d3.bisect(domain, x)];
  }
  scale.domain = function(_) {
    if (!arguments.length) return domain;
    domain = _;
    return scale;
  };
  scale.range = function(_) {
    if (!arguments.length) return range;
    range = _;
    return scale;
  };
  scale.invertExtent = function(y) {
    y = range.indexOf(y);
    return [ domain[y - 1], domain[y] ];
  };
  scale.copy = function() {
    return d3_scale_threshold(domain, range);
  };
  return scale;
}
d3.scale.identity = function() {
  return d3_scale_identity([ 0, 1 ]);
};
function d3_scale_identity(domain) {
  function identity(x) {
    return +x;
  }
  identity.invert = identity;
  identity.domain = identity.range = function(x) {
    if (!arguments.length) return domain;
    domain = x.map(identity);
    return identity;
  };
  identity.ticks = function(m) {
    return d3_scale_linearTicks(domain, m);
  };
  identity.tickFormat = function(m, format) {
    return d3_scale_linearTickFormat(domain, m, format);
  };
  identity.copy = function() {
    return d3_scale_identity(domain);
  };
  return identity;
}
d3.svg = {};
function d3_zero() {
  return 0;
}
d3.svg.arc = function() {
  var innerRadius = d3_svg_arcInnerRadius, outerRadius = d3_svg_arcOuterRadius, cornerRadius = d3_zero, padRadius = d3_svg_arcAuto, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle, padAngle = d3_svg_arcPadAngle;
  function arc() {
    var r0 = Math.max(0, +innerRadius.apply(this, arguments)), r1 = Math.max(0, +outerRadius.apply(this, arguments)), a0 = startAngle.apply(this, arguments) - halfπ, a1 = endAngle.apply(this, arguments) - halfπ, da = Math.abs(a1 - a0), cw = a0 > a1 ? 0 : 1;
    if (r1 < r0) rc = r1, r1 = r0, r0 = rc;
    if (da >= τε) return circleSegment(r1, cw) + (r0 ? circleSegment(r0, 1 - cw) : "") + "Z";
    var rc, cr, rp, ap, p0 = 0, p1 = 0, x0, y0, x1, y1, x2, y2, x3, y3, path = [];
    if (ap = (+padAngle.apply(this, arguments) || 0) / 2) {
      rp = padRadius === d3_svg_arcAuto ? Math.sqrt(r0 * r0 + r1 * r1) : +padRadius.apply(this, arguments);
      if (!cw) p1 *= -1;
      if (r1) p1 = d3_asin(rp / r1 * Math.sin(ap));
      if (r0) p0 = d3_asin(rp / r0 * Math.sin(ap));
    }
    if (r1) {
      x0 = r1 * Math.cos(a0 + p1);
      y0 = r1 * Math.sin(a0 + p1);
      x1 = r1 * Math.cos(a1 - p1);
      y1 = r1 * Math.sin(a1 - p1);
      var l1 = Math.abs(a1 - a0 - 2 * p1) <= π ? 0 : 1;
      if (p1 && d3_svg_arcSweep(x0, y0, x1, y1) === cw ^ l1) {
        var h1 = (a0 + a1) / 2;
        x0 = r1 * Math.cos(h1);
        y0 = r1 * Math.sin(h1);
        x1 = y1 = null;
      }
    } else {
      x0 = y0 = 0;
    }
    if (r0) {
      x2 = r0 * Math.cos(a1 - p0);
      y2 = r0 * Math.sin(a1 - p0);
      x3 = r0 * Math.cos(a0 + p0);
      y3 = r0 * Math.sin(a0 + p0);
      var l0 = Math.abs(a0 - a1 + 2 * p0) <= π ? 0 : 1;
      if (p0 && d3_svg_arcSweep(x2, y2, x3, y3) === 1 - cw ^ l0) {
        var h0 = (a0 + a1) / 2;
        x2 = r0 * Math.cos(h0);
        y2 = r0 * Math.sin(h0);
        x3 = y3 = null;
      }
    } else {
      x2 = y2 = 0;
    }
    if (da > ε && (rc = Math.min(Math.abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments))) > .001) {
      cr = r0 < r1 ^ cw ? 0 : 1;
      var rc1 = rc, rc0 = rc;
      if (da < π) {
        var oc = x3 == null ? [ x2, y2 ] : x1 == null ? [ x0, y0 ] : d3_geom_polygonIntersect([ x0, y0 ], [ x3, y3 ], [ x1, y1 ], [ x2, y2 ]), ax = x0 - oc[0], ay = y0 - oc[1], bx = x1 - oc[0], by = y1 - oc[1], kc = 1 / Math.sin(Math.acos((ax * bx + ay * by) / (Math.sqrt(ax * ax + ay * ay) * Math.sqrt(bx * bx + by * by))) / 2), lc = Math.sqrt(oc[0] * oc[0] + oc[1] * oc[1]);
        rc0 = Math.min(rc, (r0 - lc) / (kc - 1));
        rc1 = Math.min(rc, (r1 - lc) / (kc + 1));
      }
      if (x1 != null) {
        var t30 = d3_svg_arcCornerTangents(x3 == null ? [ x2, y2 ] : [ x3, y3 ], [ x0, y0 ], r1, rc1, cw), t12 = d3_svg_arcCornerTangents([ x1, y1 ], [ x2, y2 ], r1, rc1, cw);
        if (rc === rc1) {
          path.push("M", t30[0], "A", rc1, ",", rc1, " 0 0,", cr, " ", t30[1], "A", r1, ",", r1, " 0 ", 1 - cw ^ d3_svg_arcSweep(t30[1][0], t30[1][1], t12[1][0], t12[1][1]), ",", cw, " ", t12[1], "A", rc1, ",", rc1, " 0 0,", cr, " ", t12[0]);
        } else {
          path.push("M", t30[0], "A", rc1, ",", rc1, " 0 1,", cr, " ", t12[0]);
        }
      } else {
        path.push("M", x0, ",", y0);
      }
      if (x3 != null) {
        var t03 = d3_svg_arcCornerTangents([ x0, y0 ], [ x3, y3 ], r0, -rc0, cw), t21 = d3_svg_arcCornerTangents([ x2, y2 ], x1 == null ? [ x0, y0 ] : [ x1, y1 ], r0, -rc0, cw);
        if (rc === rc0) {
          path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t21[1], "A", r0, ",", r0, " 0 ", cw ^ d3_svg_arcSweep(t21[1][0], t21[1][1], t03[1][0], t03[1][1]), ",", 1 - cw, " ", t03[1], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);
        } else {
          path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);
        }
      } else {
        path.push("L", x2, ",", y2);
      }
    } else {
      path.push("M", x0, ",", y0);
      if (x1 != null) path.push("A", r1, ",", r1, " 0 ", l1, ",", cw, " ", x1, ",", y1);
      path.push("L", x2, ",", y2);
      if (x3 != null) path.push("A", r0, ",", r0, " 0 ", l0, ",", 1 - cw, " ", x3, ",", y3);
    }
    path.push("Z");
    return path.join("");
  }
  function circleSegment(r1, cw) {
    return "M0," + r1 + "A" + r1 + "," + r1 + " 0 1," + cw + " 0," + -r1 + "A" + r1 + "," + r1 + " 0 1," + cw + " 0," + r1;
  }
  arc.innerRadius = function(v) {
    if (!arguments.length) return innerRadius;
    innerRadius = d3_functor(v);
    return arc;
  };
  arc.outerRadius = function(v) {
    if (!arguments.length) return outerRadius;
    outerRadius = d3_functor(v);
    return arc;
  };
  arc.cornerRadius = function(v) {
    if (!arguments.length) return cornerRadius;
    cornerRadius = d3_functor(v);
    return arc;
  };
  arc.padRadius = function(v) {
    if (!arguments.length) return padRadius;
    padRadius = v == d3_svg_arcAuto ? d3_svg_arcAuto : d3_functor(v);
    return arc;
  };
  arc.startAngle = function(v) {
    if (!arguments.length) return startAngle;
    startAngle = d3_functor(v);
    return arc;
  };
  arc.endAngle = function(v) {
    if (!arguments.length) return endAngle;
    endAngle = d3_functor(v);
    return arc;
  };
  arc.padAngle = function(v) {
    if (!arguments.length) return padAngle;
    padAngle = d3_functor(v);
    return arc;
  };
  arc.centroid = function() {
    var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - halfπ;
    return [ Math.cos(a) * r, Math.sin(a) * r ];
  };
  return arc;
};
var d3_svg_arcAuto = "auto";
function d3_svg_arcInnerRadius(d) {
  return d.innerRadius;
}
function d3_svg_arcOuterRadius(d) {
  return d.outerRadius;
}
function d3_svg_arcStartAngle(d) {
  return d.startAngle;
}
function d3_svg_arcEndAngle(d) {
  return d.endAngle;
}
function d3_svg_arcPadAngle(d) {
  return d && d.padAngle;
}
function d3_svg_arcSweep(x0, y0, x1, y1) {
  return (x0 - x1) * y0 - (y0 - y1) * x0 > 0 ? 0 : 1;
}
function d3_svg_arcCornerTangents(p0, p1, r1, rc, cw) {
  var x01 = p0[0] - p1[0], y01 = p0[1] - p1[1], lo = (cw ? rc : -rc) / Math.sqrt(x01 * x01 + y01 * y01), ox = lo * y01, oy = -lo * x01, x1 = p0[0] + ox, y1 = p0[1] + oy, x2 = p1[0] + ox, y2 = p1[1] + oy, x3 = (x1 + x2) / 2, y3 = (y1 + y2) / 2, dx = x2 - x1, dy = y2 - y1, d2 = dx * dx + dy * dy, r = r1 - rc, D = x1 * y2 - x2 * y1, d = (dy < 0 ? -1 : 1) * Math.sqrt(Math.max(0, r * r * d2 - D * D)), cx0 = (D * dy - dx * d) / d2, cy0 = (-D * dx - dy * d) / d2, cx1 = (D * dy + dx * d) / d2, cy1 = (-D * dx + dy * d) / d2, dx0 = cx0 - x3, dy0 = cy0 - y3, dx1 = cx1 - x3, dy1 = cy1 - y3;
  if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;
  return [ [ cx0 - ox, cy0 - oy ], [ cx0 * r1 / r, cy0 * r1 / r ] ];
}
function d3_svg_line(projection) {
  var x = d3_geom_pointX, y = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, tension = .7;
  function line(data) {
    var segments = [], points = [], i = -1, n = data.length, d, fx = d3_functor(x), fy = d3_functor(y);
    function segment() {
      segments.push("M", interpolate(projection(points), tension));
    }
    while (++i < n) {
      if (defined.call(this, d = data[i], i)) {
        points.push([ +fx.call(this, d, i), +fy.call(this, d, i) ]);
      } else if (points.length) {
        segment();
        points = [];
      }
    }
    if (points.length) segment();
    return segments.length ? segments.join("") : null;
  }
  line.x = function(_) {
    if (!arguments.length) return x;
    x = _;
    return line;
  };
  line.y = function(_) {
    if (!arguments.length) return y;
    y = _;
    return line;
  };
  line.defined = function(_) {
    if (!arguments.length) return defined;
    defined = _;
    return line;
  };
  line.interpolate = function(_) {
    if (!arguments.length) return interpolateKey;
    if (typeof _ === "function") interpolateKey = interpolate = _; else interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_) || d3_svg_lineLinear).key;
    return line;
  };
  line.tension = function(_) {
    if (!arguments.length) return tension;
    tension = _;
    return line;
  };
  return line;
}
d3.svg.line = function() {
  return d3_svg_line(d3_identity);
};
var d3_svg_lineInterpolators = d3.map({
  linear: d3_svg_lineLinear,
  "linear-closed": d3_svg_lineLinearClosed,
  step: d3_svg_lineStep,
  "step-before": d3_svg_lineStepBefore,
  "step-after": d3_svg_lineStepAfter,
  basis: d3_svg_lineBasis,
  "basis-open": d3_svg_lineBasisOpen,
  "basis-closed": d3_svg_lineBasisClosed,
  bundle: d3_svg_lineBundle,
  cardinal: d3_svg_lineCardinal,
  "cardinal-open": d3_svg_lineCardinalOpen,
  "cardinal-closed": d3_svg_lineCardinalClosed,
  monotone: d3_svg_lineMonotone
});
d3_svg_lineInterpolators.forEach(function(key, value) {
  value.key = key;
  value.closed = /-closed$/.test(key);
});
function d3_svg_lineLinear(points) {
  return points.length > 1 ? points.join("L") : points + "Z";
}
function d3_svg_lineLinearClosed(points) {
  return points.join("L") + "Z";
}
function d3_svg_lineStep(points) {
  var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
  while (++i < n) path.push("H", (p[0] + (p = points[i])[0]) / 2, "V", p[1]);
  if (n > 1) path.push("H", p[0]);
  return path.join("");
}
function d3_svg_lineStepBefore(points) {
  var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
  while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]);
  return path.join("");
}
function d3_svg_lineStepAfter(points) {
  var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
  while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]);
  return path.join("");
}
function d3_svg_lineCardinalOpen(points, tension) {
  return points.length < 4 ? d3_svg_lineLinear(points) : points[1] + d3_svg_lineHermite(points.slice(1, -1), d3_svg_lineCardinalTangents(points, tension));
}
function d3_svg_lineCardinalClosed(points, tension) {
  return points.length < 3 ? d3_svg_lineLinearClosed(points) : points[0] + d3_svg_lineHermite((points.push(points[0]), 
  points), d3_svg_lineCardinalTangents([ points[points.length - 2] ].concat(points, [ points[1] ]), tension));
}
function d3_svg_lineCardinal(points, tension) {
  return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineCardinalTangents(points, tension));
}
function d3_svg_lineHermite(points, tangents) {
  if (tangents.length < 1 || points.length != tangents.length && points.length != tangents.length + 2) {
    return d3_svg_lineLinear(points);
  }
  var quad = points.length != tangents.length, path = "", p0 = points[0], p = points[1], t0 = tangents[0], t = t0, pi = 1;
  if (quad) {
    path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3) + "," + p[0] + "," + p[1];
    p0 = points[1];
    pi = 2;
  }
  if (tangents.length > 1) {
    t = tangents[1];
    p = points[pi];
    pi++;
    path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1]) + "," + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];
    for (var i = 2; i < tangents.length; i++, pi++) {
      p = points[pi];
      t = tangents[i];
      path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];
    }
  }
  if (quad) {
    var lp = points[pi];
    path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3) + "," + lp[0] + "," + lp[1];
  }
  return path;
}
function d3_svg_lineCardinalTangents(points, tension) {
  var tangents = [], a = (1 - tension) / 2, p0, p1 = points[0], p2 = points[1], i = 1, n = points.length;
  while (++i < n) {
    p0 = p1;
    p1 = p2;
    p2 = points[i];
    tangents.push([ a * (p2[0] - p0[0]), a * (p2[1] - p0[1]) ]);
  }
  return tangents;
}
function d3_svg_lineBasis(points) {
  if (points.length < 3) return d3_svg_lineLinear(points);
  var i = 1, n = points.length, pi = points[0], x0 = pi[0], y0 = pi[1], px = [ x0, x0, x0, (pi = points[1])[0] ], py = [ y0, y0, y0, pi[1] ], path = [ x0, ",", y0, "L", d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py) ];
  points.push(points[n - 1]);
  while (++i <= n) {
    pi = points[i];
    px.shift();
    px.push(pi[0]);
    py.shift();
    py.push(pi[1]);
    d3_svg_lineBasisBezier(path, px, py);
  }
  points.pop();
  path.push("L", pi);
  return path.join("");
}
function d3_svg_lineBasisOpen(points) {
  if (points.length < 4) return d3_svg_lineLinear(points);
  var path = [], i = -1, n = points.length, pi, px = [ 0 ], py = [ 0 ];
  while (++i < 3) {
    pi = points[i];
    px.push(pi[0]);
    py.push(pi[1]);
  }
  path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px) + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, py));
  --i;
  while (++i < n) {
    pi = points[i];
    px.shift();
    px.push(pi[0]);
    py.shift();
    py.push(pi[1]);
    d3_svg_lineBasisBezier(path, px, py);
  }
  return path.join("");
}
function d3_svg_lineBasisClosed(points) {
  var path, i = -1, n = points.length, m = n + 4, pi, px = [], py = [];
  while (++i < 4) {
    pi = points[i % n];
    px.push(pi[0]);
    py.push(pi[1]);
  }
  path = [ d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py) ];
  --i;
  while (++i < m) {
    pi = points[i % n];
    px.shift();
    px.push(pi[0]);
    py.shift();
    py.push(pi[1]);
    d3_svg_lineBasisBezier(path, px, py);
  }
  return path.join("");
}
function d3_svg_lineBundle(points, tension) {
  var n = points.length - 1;
  if (n) {
    var x0 = points[0][0], y0 = points[0][1], dx = points[n][0] - x0, dy = points[n][1] - y0, i = -1, p, t;
    while (++i <= n) {
      p = points[i];
      t = i / n;
      p[0] = tension * p[0] + (1 - tension) * (x0 + t * dx);
      p[1] = tension * p[1] + (1 - tension) * (y0 + t * dy);
    }
  }
  return d3_svg_lineBasis(points);
}
function d3_svg_lineDot4(a, b) {
  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
}
var d3_svg_lineBasisBezier1 = [ 0, 2 / 3, 1 / 3, 0 ], d3_svg_lineBasisBezier2 = [ 0, 1 / 3, 2 / 3, 0 ], d3_svg_lineBasisBezier3 = [ 0, 1 / 6, 2 / 3, 1 / 6 ];
function d3_svg_lineBasisBezier(path, x, y) {
  path.push("C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, y));
}
function d3_svg_lineSlope(p0, p1) {
  return (p1[1] - p0[1]) / (p1[0] - p0[0]);
}
function d3_svg_lineFiniteDifferences(points) {
  var i = 0, j = points.length - 1, m = [], p0 = points[0], p1 = points[1], d = m[0] = d3_svg_lineSlope(p0, p1);
  while (++i < j) {
    m[i] = (d + (d = d3_svg_lineSlope(p0 = p1, p1 = points[i + 1]))) / 2;
  }
  m[i] = d;
  return m;
}
function d3_svg_lineMonotoneTangents(points) {
  var tangents = [], d, a, b, s, m = d3_svg_lineFiniteDifferences(points), i = -1, j = points.length - 1;
  while (++i < j) {
    d = d3_svg_lineSlope(points[i], points[i + 1]);
    if (abs(d) < ε) {
      m[i] = m[i + 1] = 0;
    } else {
      a = m[i] / d;
      b = m[i + 1] / d;
      s = a * a + b * b;
      if (s > 9) {
        s = d * 3 / Math.sqrt(s);
        m[i] = s * a;
        m[i + 1] = s * b;
      }
    }
  }
  i = -1;
  while (++i <= j) {
    s = (points[Math.min(j, i + 1)][0] - points[Math.max(0, i - 1)][0]) / (6 * (1 + m[i] * m[i]));
    tangents.push([ s || 0, m[i] * s || 0 ]);
  }
  return tangents;
}
function d3_svg_lineMonotone(points) {
  return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineMonotoneTangents(points));
}
d3.svg.line.radial = function() {
  var line = d3_svg_line(d3_svg_lineRadial);
  line.radius = line.x, delete line.x;
  line.angle = line.y, delete line.y;
  return line;
};
function d3_svg_lineRadial(points) {
  var point, i = -1, n = points.length, r, a;
  while (++i < n) {
    point = points[i];
    r = point[0];
    a = point[1] - halfπ;
    point[0] = r * Math.cos(a);
    point[1] = r * Math.sin(a);
  }
  return points;
}
function d3_svg_area(projection) {
  var x0 = d3_geom_pointX, x1 = d3_geom_pointX, y0 = 0, y1 = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, interpolateReverse = interpolate, L = "L", tension = .7;
  function area(data) {
    var segments = [], points0 = [], points1 = [], i = -1, n = data.length, d, fx0 = d3_functor(x0), fy0 = d3_functor(y0), fx1 = x0 === x1 ? function() {
      return x;
    } : d3_functor(x1), fy1 = y0 === y1 ? function() {
      return y;
    } : d3_functor(y1), x, y;
    function segment() {
      segments.push("M", interpolate(projection(points1), tension), L, interpolateReverse(projection(points0.reverse()), tension), "Z");
    }
    while (++i < n) {
      if (defined.call(this, d = data[i], i)) {
        points0.push([ x = +fx0.call(this, d, i), y = +fy0.call(this, d, i) ]);
        points1.push([ +fx1.call(this, d, i), +fy1.call(this, d, i) ]);
      } else if (points0.length) {
        segment();
        points0 = [];
        points1 = [];
      }
    }
    if (points0.length) segment();
    return segments.length ? segments.join("") : null;
  }
  area.x = function(_) {
    if (!arguments.length) return x1;
    x0 = x1 = _;
    return area;
  };
  area.x0 = function(_) {
    if (!arguments.length) return x0;
    x0 = _;
    return area;
  };
  area.x1 = function(_) {
    if (!arguments.length) return x1;
    x1 = _;
    return area;
  };
  area.y = function(_) {
    if (!arguments.length) return y1;
    y0 = y1 = _;
    return area;
  };
  area.y0 = function(_) {
    if (!arguments.length) return y0;
    y0 = _;
    return area;
  };
  area.y1 = function(_) {
    if (!arguments.length) return y1;
    y1 = _;
    return area;
  };
  area.defined = function(_) {
    if (!arguments.length) return defined;
    defined = _;
    return area;
  };
  area.interpolate = function(_) {
    if (!arguments.length) return interpolateKey;
    if (typeof _ === "function") interpolateKey = interpolate = _; else interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_) || d3_svg_lineLinear).key;
    interpolateReverse = interpolate.reverse || interpolate;
    L = interpolate.closed ? "M" : "L";
    return area;
  };
  area.tension = function(_) {
    if (!arguments.length) return tension;
    tension = _;
    return area;
  };
  return area;
}
d3_svg_lineStepBefore.reverse = d3_svg_lineStepAfter;
d3_svg_lineStepAfter.reverse = d3_svg_lineStepBefore;
d3.svg.area = function() {
  return d3_svg_area(d3_identity);
};
d3.svg.area.radial = function() {
  var area = d3_svg_area(d3_svg_lineRadial);
  area.radius = area.x, delete area.x;
  area.innerRadius = area.x0, delete area.x0;
  area.outerRadius = area.x1, delete area.x1;
  area.angle = area.y, delete area.y;
  area.startAngle = area.y0, delete area.y0;
  area.endAngle = area.y1, delete area.y1;
  return area;
};
d3.svg.chord = function() {
  var source = d3_source, target = d3_target, radius = d3_svg_chordRadius, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle;
  function chord(d, i) {
    var s = subgroup(this, source, d, i), t = subgroup(this, target, d, i);
    return "M" + s.p0 + arc(s.r, s.p1, s.a1 - s.a0) + (equals(s, t) ? curve(s.r, s.p1, s.r, s.p0) : curve(s.r, s.p1, t.r, t.p0) + arc(t.r, t.p1, t.a1 - t.a0) + curve(t.r, t.p1, s.r, s.p0)) + "Z";
  }
  function subgroup(self, f, d, i) {
    var subgroup = f.call(self, d, i), r = radius.call(self, subgroup, i), a0 = startAngle.call(self, subgroup, i) - halfπ, a1 = endAngle.call(self, subgroup, i) - halfπ;
    return {
      r: r,
      a0: a0,
      a1: a1,
      p0: [ r * Math.cos(a0), r * Math.sin(a0) ],
      p1: [ r * Math.cos(a1), r * Math.sin(a1) ]
    };
  }
  function equals(a, b) {
    return a.a0 == b.a0 && a.a1 == b.a1;
  }
  function arc(r, p, a) {
    return "A" + r + "," + r + " 0 " + +(a > π) + ",1 " + p;
  }
  function curve(r0, p0, r1, p1) {
    return "Q 0,0 " + p1;
  }
  chord.radius = function(v) {
    if (!arguments.length) return radius;
    radius = d3_functor(v);
    return chord;
  };
  chord.source = function(v) {
    if (!arguments.length) return source;
    source = d3_functor(v);
    return chord;
  };
  chord.target = function(v) {
    if (!arguments.length) return target;
    target = d3_functor(v);
    return chord;
  };
  chord.startAngle = function(v) {
    if (!arguments.length) return startAngle;
    startAngle = d3_functor(v);
    return chord;
  };
  chord.endAngle = function(v) {
    if (!arguments.length) return endAngle;
    endAngle = d3_functor(v);
    return chord;
  };
  return chord;
};
function d3_svg_chordRadius(d) {
  return d.radius;
}
d3.svg.diagonal = function() {
  var source = d3_source, target = d3_target, projection = d3_svg_diagonalProjection;
  function diagonal(d, i) {
    var p0 = source.call(this, d, i), p3 = target.call(this, d, i), m = (p0.y + p3.y) / 2, p = [ p0, {
      x: p0.x,
      y: m
    }, {
      x: p3.x,
      y: m
    }, p3 ];
    p = p.map(projection);
    return "M" + p[0] + "C" + p[1] + " " + p[2] + " " + p[3];
  }
  diagonal.source = function(x) {
    if (!arguments.length) return source;
    source = d3_functor(x);
    return diagonal;
  };
  diagonal.target = function(x) {
    if (!arguments.length) return target;
    target = d3_functor(x);
    return diagonal;
  };
  diagonal.projection = function(x) {
    if (!arguments.length) return projection;
    projection = x;
    return diagonal;
  };
  return diagonal;
};
function d3_svg_diagonalProjection(d) {
  return [ d.x, d.y ];
}
d3.svg.diagonal.radial = function() {
  var diagonal = d3.svg.diagonal(), projection = d3_svg_diagonalProjection, projection_ = diagonal.projection;
  diagonal.projection = function(x) {
    return arguments.length ? projection_(d3_svg_diagonalRadialProjection(projection = x)) : projection;
  };
  return diagonal;
};
function d3_svg_diagonalRadialProjection(projection) {
  return function() {
    var d = projection.apply(this, arguments), r = d[0], a = d[1] - halfπ;
    return [ r * Math.cos(a), r * Math.sin(a) ];
  };
}
d3.svg.symbol = function() {
  var type = d3_svg_symbolType, size = d3_svg_symbolSize;
  function symbol(d, i) {
    return (d3_svg_symbols.get(type.call(this, d, i)) || d3_svg_symbolCircle)(size.call(this, d, i));
  }
  symbol.type = function(x) {
    if (!arguments.length) return type;
    type = d3_functor(x);
    return symbol;
  };
  symbol.size = function(x) {
    if (!arguments.length) return size;
    size = d3_functor(x);
    return symbol;
  };
  return symbol;
};
function d3_svg_symbolSize() {
  return 64;
}
function d3_svg_symbolType() {
  return "circle";
}
function d3_svg_symbolCircle(size) {
  var r = Math.sqrt(size / π);
  return "M0," + r + "A" + r + "," + r + " 0 1,1 0," + -r + "A" + r + "," + r + " 0 1,1 0," + r + "Z";
}
var d3_svg_symbols = d3.map({
  circle: d3_svg_symbolCircle,
  cross: function(size) {
    var r = Math.sqrt(size / 5) / 2;
    return "M" + -3 * r + "," + -r + "H" + -r + "V" + -3 * r + "H" + r + "V" + -r + "H" + 3 * r + "V" + r + "H" + r + "V" + 3 * r + "H" + -r + "V" + r + "H" + -3 * r + "Z";
  },
  diamond: function(size) {
    var ry = Math.sqrt(size / (2 * d3_svg_symbolTan30)), rx = ry * d3_svg_symbolTan30;
    return "M0," + -ry + "L" + rx + ",0" + " 0," + ry + " " + -rx + ",0" + "Z";
  },
  square: function(size) {
    var r = Math.sqrt(size) / 2;
    return "M" + -r + "," + -r + "L" + r + "," + -r + " " + r + "," + r + " " + -r + "," + r + "Z";
  },
  "triangle-down": function(size) {
    var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2;
    return "M0," + ry + "L" + rx + "," + -ry + " " + -rx + "," + -ry + "Z";
  },
  "triangle-up": function(size) {
    var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2;
    return "M0," + -ry + "L" + rx + "," + ry + " " + -rx + "," + ry + "Z";
  }
});
d3.svg.symbolTypes = d3_svg_symbols.keys();
var d3_svg_symbolSqrt3 = Math.sqrt(3), d3_svg_symbolTan30 = Math.tan(30 * d3_radians);
d3_selectionPrototype.transition = function(name) {
  var id = d3_transitionInheritId || ++d3_transitionId, ns = d3_transitionNamespace(name), subgroups = [], subgroup, node, transition = d3_transitionInherit || {
    time: Date.now(),
    ease: d3_ease_cubicInOut,
    delay: 0,
    duration: 250
  };
  for (var j = -1, m = this.length; ++j < m; ) {
    subgroups.push(subgroup = []);
    for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
      if (node = group[i]) d3_transitionNode(node, i, ns, id, transition);
      subgroup.push(node);
    }
  }
  return d3_transition(subgroups, ns, id);
};
d3_selectionPrototype.interrupt = function(name) {
  return this.each(name == null ? d3_selection_interrupt : d3_selection_interruptNS(d3_transitionNamespace(name)));
};
var d3_selection_interrupt = d3_selection_interruptNS(d3_transitionNamespace());
function d3_selection_interruptNS(ns) {
  return function() {
    var lock, activeId, active;
    if ((lock = this[ns]) && (active = lock[activeId = lock.active])) {
      active.timer.c = null;
      active.timer.t = NaN;
      if (--lock.count) delete lock[activeId]; else delete this[ns];
      lock.active += .5;
      active.event && active.event.interrupt.call(this, this.__data__, active.index);
    }
  };
}
function d3_transition(groups, ns, id) {
  d3_subclass(groups, d3_transitionPrototype);
  groups.namespace = ns;
  groups.id = id;
  return groups;
}
var d3_transitionPrototype = [], d3_transitionId = 0, d3_transitionInheritId, d3_transitionInherit;
d3_transitionPrototype.call = d3_selectionPrototype.call;
d3_transitionPrototype.empty = d3_selectionPrototype.empty;
d3_transitionPrototype.node = d3_selectionPrototype.node;
d3_transitionPrototype.size = d3_selectionPrototype.size;
d3.transition = function(selection, name) {
  return selection && selection.transition ? d3_transitionInheritId ? selection.transition(name) : selection : d3.selection().transition(selection);
};
d3.transition.prototype = d3_transitionPrototype;
d3_transitionPrototype.select = function(selector) {
  var id = this.id, ns = this.namespace, subgroups = [], subgroup, subnode, node;
  selector = d3_selection_selector(selector);
  for (var j = -1, m = this.length; ++j < m; ) {
    subgroups.push(subgroup = []);
    for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
      if ((node = group[i]) && (subnode = selector.call(node, node.__data__, i, j))) {
        if ("__data__" in node) subnode.__data__ = node.__data__;
        d3_transitionNode(subnode, i, ns, id, node[ns][id]);
        subgroup.push(subnode);
      } else {
        subgroup.push(null);
      }
    }
  }
  return d3_transition(subgroups, ns, id);
};
d3_transitionPrototype.selectAll = function(selector) {
  var id = this.id, ns = this.namespace, subgroups = [], subgroup, subnodes, node, subnode, transition;
  selector = d3_selection_selectorAll(selector);
  for (var j = -1, m = this.length; ++j < m; ) {
    for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
      if (node = group[i]) {
        transition = node[ns][id];
        subnodes = selector.call(node, node.__data__, i, j);
        subgroups.push(subgroup = []);
        for (var k = -1, o = subnodes.length; ++k < o; ) {
          if (subnode = subnodes[k]) d3_transitionNode(subnode, k, ns, id, transition);
          subgroup.push(subnode);
        }
      }
    }
  }
  return d3_transition(subgroups, ns, id);
};
d3_transitionPrototype.filter = function(filter) {
  var subgroups = [], subgroup, group, node;
  if (typeof filter !== "function") filter = d3_selection_filter(filter);
  for (var j = 0, m = this.length; j < m; j++) {
    subgroups.push(subgroup = []);
    for (var group = this[j], i = 0, n = group.length; i < n; i++) {
      if ((node = group[i]) && filter.call(node, node.__data__, i, j)) {
        subgroup.push(node);
      }
    }
  }
  return d3_transition(subgroups, this.namespace, this.id);
};
d3_transitionPrototype.tween = function(name, tween) {
  var id = this.id, ns = this.namespace;
  if (arguments.length < 2) return this.node()[ns][id].tween.get(name);
  return d3_selection_each(this, tween == null ? function(node) {
    node[ns][id].tween.remove(name);
  } : function(node) {
    node[ns][id].tween.set(name, tween);
  });
};
function d3_transition_tween(groups, name, value, tween) {
  var id = groups.id, ns = groups.namespace;
  return d3_selection_each(groups, typeof value === "function" ? function(node, i, j) {
    node[ns][id].tween.set(name, tween(value.call(node, node.__data__, i, j)));
  } : (value = tween(value), function(node) {
    node[ns][id].tween.set(name, value);
  }));
}
d3_transitionPrototype.attr = function(nameNS, value) {
  if (arguments.length < 2) {
    for (value in nameNS) this.attr(value, nameNS[value]);
    return this;
  }
  var interpolate = nameNS == "transform" ? d3_interpolateTransform : d3_interpolate, name = d3.ns.qualify(nameNS);
  function attrNull() {
    this.removeAttribute(name);
  }
  function attrNullNS() {
    this.removeAttributeNS(name.space, name.local);
  }
  function attrTween(b) {
    return b == null ? attrNull : (b += "", function() {
      var a = this.getAttribute(name), i;
      return a !== b && (i = interpolate(a, b), function(t) {
        this.setAttribute(name, i(t));
      });
    });
  }
  function attrTweenNS(b) {
    return b == null ? attrNullNS : (b += "", function() {
      var a = this.getAttributeNS(name.space, name.local), i;
      return a !== b && (i = interpolate(a, b), function(t) {
        this.setAttributeNS(name.space, name.local, i(t));
      });
    });
  }
  return d3_transition_tween(this, "attr." + nameNS, value, name.local ? attrTweenNS : attrTween);
};
d3_transitionPrototype.attrTween = function(nameNS, tween) {
  var name = d3.ns.qualify(nameNS);
  function attrTween(d, i) {
    var f = tween.call(this, d, i, this.getAttribute(name));
    return f && function(t) {
      this.setAttribute(name, f(t));
    };
  }
  function attrTweenNS(d, i) {
    var f = tween.call(this, d, i, this.getAttributeNS(name.space, name.local));
    return f && function(t) {
      this.setAttributeNS(name.space, name.local, f(t));
    };
  }
  return this.tween("attr." + nameNS, name.local ? attrTweenNS : attrTween);
};
d3_transitionPrototype.style = function(name, value, priority) {
  var n = arguments.length;
  if (n < 3) {
    if (typeof name !== "string") {
      if (n < 2) value = "";
      for (priority in name) this.style(priority, name[priority], value);
      return this;
    }
    priority = "";
  }
  function styleNull() {
    this.style.removeProperty(name);
  }
  function styleString(b) {
    return b == null ? styleNull : (b += "", function() {
      var a = d3_window(this).getComputedStyle(this, null).getPropertyValue(name), i;
      return a !== b && (i = d3_interpolate(a, b), function(t) {
        this.style.setProperty(name, i(t), priority);
      });
    });
  }
  return d3_transition_tween(this, "style." + name, value, styleString);
};
d3_transitionPrototype.styleTween = function(name, tween, priority) {
  if (arguments.length < 3) priority = "";
  function styleTween(d, i) {
    var f = tween.call(this, d, i, d3_window(this).getComputedStyle(this, null).getPropertyValue(name));
    return f && function(t) {
      this.style.setProperty(name, f(t), priority);
    };
  }
  return this.tween("style." + name, styleTween);
};
d3_transitionPrototype.text = function(value) {
  return d3_transition_tween(this, "text", value, d3_transition_text);
};
function d3_transition_text(b) {
  if (b == null) b = "";
  return function() {
    this.textContent = b;
  };
}
d3_transitionPrototype.remove = function() {
  var ns = this.namespace;
  return this.each("end.transition", function() {
    var p;
    if (this[ns].count < 2 && (p = this.parentNode)) p.removeChild(this);
  });
};
d3_transitionPrototype.ease = function(value) {
  var id = this.id, ns = this.namespace;
  if (arguments.length < 1) return this.node()[ns][id].ease;
  if (typeof value !== "function") value = d3.ease.apply(d3, arguments);
  return d3_selection_each(this, function(node) {
    node[ns][id].ease = value;
  });
};
d3_transitionPrototype.delay = function(value) {
  var id = this.id, ns = this.namespace;
  if (arguments.length < 1) return this.node()[ns][id].delay;
  return d3_selection_each(this, typeof value === "function" ? function(node, i, j) {
    node[ns][id].delay = +value.call(node, node.__data__, i, j);
  } : (value = +value, function(node) {
    node[ns][id].delay = value;
  }));
};
d3_transitionPrototype.duration = function(value) {
  var id = this.id, ns = this.namespace;
  if (arguments.length < 1) return this.node()[ns][id].duration;
  return d3_selection_each(this, typeof value === "function" ? function(node, i, j) {
    node[ns][id].duration = Math.max(1, value.call(node, node.__data__, i, j));
  } : (value = Math.max(1, value), function(node) {
    node[ns][id].duration = value;
  }));
};
d3_transitionPrototype.each = function(type, listener) {
  var id = this.id, ns = this.namespace;
  if (arguments.length < 2) {
    var inherit = d3_transitionInherit, inheritId = d3_transitionInheritId;
    try {
      d3_transitionInheritId = id;
      d3_selection_each(this, function(node, i, j) {
        d3_transitionInherit = node[ns][id];
        type.call(node, node.__data__, i, j);
      });
    } finally {
      d3_transitionInherit = inherit;
      d3_transitionInheritId = inheritId;
    }
  } else {
    d3_selection_each(this, function(node) {
      var transition = node[ns][id];
      (transition.event || (transition.event = d3.dispatch("start", "end", "interrupt"))).on(type, listener);
    });
  }
  return this;
};
d3_transitionPrototype.transition = function() {
  var id0 = this.id, id1 = ++d3_transitionId, ns = this.namespace, subgroups = [], subgroup, group, node, transition;
  for (var j = 0, m = this.length; j < m; j++) {
    subgroups.push(subgroup = []);
    for (var group = this[j], i = 0, n = group.length; i < n; i++) {
      if (node = group[i]) {
        transition = node[ns][id0];
        d3_transitionNode(node, i, ns, id1, {
          time: transition.time,
          ease: transition.ease,
          delay: transition.delay + transition.duration,
          duration: transition.duration
        });
      }
      subgroup.push(node);
    }
  }
  return d3_transition(subgroups, ns, id1);
};
function d3_transitionNamespace(name) {
  return name == null ? "__transition__" : "__transition_" + name + "__";
}
function d3_transitionNode(node, i, ns, id, inherit) {
  var lock = node[ns] || (node[ns] = {
    active: 0,
    count: 0
  }), transition = lock[id], time, timer, duration, ease, tweens;
  function schedule(elapsed) {
    var delay = transition.delay;
    timer.t = delay + time;
    if (delay <= elapsed) return start(elapsed - delay);
    timer.c = start;
  }
  function start(elapsed) {
    var activeId = lock.active, active = lock[activeId];
    if (active) {
      active.timer.c = null;
      active.timer.t = NaN;
      --lock.count;
      delete lock[activeId];
      active.event && active.event.interrupt.call(node, node.__data__, active.index);
    }
    for (var cancelId in lock) {
      if (+cancelId < id) {
        var cancel = lock[cancelId];
        cancel.timer.c = null;
        cancel.timer.t = NaN;
        --lock.count;
        delete lock[cancelId];
      }
    }
    timer.c = tick;
    d3_timer(function() {
      if (timer.c && tick(elapsed || 1)) {
        timer.c = null;
        timer.t = NaN;
      }
      return 1;
    }, 0, time);
    lock.active = id;
    transition.event && transition.event.start.call(node, node.__data__, i);
    tweens = [];
    transition.tween.forEach(function(key, value) {
      if (value = value.call(node, node.__data__, i)) {
        tweens.push(value);
      }
    });
    ease = transition.ease;
    duration = transition.duration;
  }
  function tick(elapsed) {
    var t = elapsed / duration, e = ease(t), n = tweens.length;
    while (n > 0) {
      tweens[--n].call(node, e);
    }
    if (t >= 1) {
      transition.event && transition.event.end.call(node, node.__data__, i);
      if (--lock.count) delete lock[id]; else delete node[ns];
      return 1;
    }
  }
  if (!transition) {
    time = inherit.time;
    timer = d3_timer(schedule, 0, time);
    transition = lock[id] = {
      tween: new d3_Map(),
      time: time,
      timer: timer,
      delay: inherit.delay,
      duration: inherit.duration,
      ease: inherit.ease,
      index: i
    };
    inherit = null;
    ++lock.count;
  }
}
d3.svg.axis = function() {
  var scale = d3.scale.linear(), orient = d3_svg_axisDefaultOrient, innerTickSize = 6, outerTickSize = 6, tickPadding = 3, tickArguments_ = [ 10 ], tickValues = null, tickFormat_;
  function axis(g) {
    g.each(function() {
      var g = d3.select(this);
      var scale0 = this.__chart__ || scale, scale1 = this.__chart__ = scale.copy();
      var ticks = tickValues == null ? scale1.ticks ? scale1.ticks.apply(scale1, tickArguments_) : scale1.domain() : tickValues, tickFormat = tickFormat_ == null ? scale1.tickFormat ? scale1.tickFormat.apply(scale1, tickArguments_) : d3_identity : tickFormat_, tick = g.selectAll(".tick").data(ticks, scale1), tickEnter = tick.enter().insert("g", ".domain").attr("class", "tick").style("opacity", ε), tickExit = d3.transition(tick.exit()).style("opacity", ε).remove(), tickUpdate = d3.transition(tick.order()).style("opacity", 1), tickSpacing = Math.max(innerTickSize, 0) + tickPadding, tickTransform;
      var range = d3_scaleRange(scale1), path = g.selectAll(".domain").data([ 0 ]), pathUpdate = (path.enter().append("path").attr("class", "domain"), 
      d3.transition(path));
      tickEnter.append("line");
      tickEnter.append("text");
      var lineEnter = tickEnter.select("line"), lineUpdate = tickUpdate.select("line"), text = tick.select("text").text(tickFormat), textEnter = tickEnter.select("text"), textUpdate = tickUpdate.select("text"), sign = orient === "top" || orient === "left" ? -1 : 1, x1, x2, y1, y2;
      if (orient === "bottom" || orient === "top") {
        tickTransform = d3_svg_axisX, x1 = "x", y1 = "y", x2 = "x2", y2 = "y2";
        text.attr("dy", sign < 0 ? "0em" : ".71em").style("text-anchor", "middle");
        pathUpdate.attr("d", "M" + range[0] + "," + sign * outerTickSize + "V0H" + range[1] + "V" + sign * outerTickSize);
      } else {
        tickTransform = d3_svg_axisY, x1 = "y", y1 = "x", x2 = "y2", y2 = "x2";
        text.attr("dy", ".32em").style("text-anchor", sign < 0 ? "end" : "start");
        pathUpdate.attr("d", "M" + sign * outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + sign * outerTickSize);
      }
      lineEnter.attr(y2, sign * innerTickSize);
      textEnter.attr(y1, sign * tickSpacing);
      lineUpdate.attr(x2, 0).attr(y2, sign * innerTickSize);
      textUpdate.attr(x1, 0).attr(y1, sign * tickSpacing);
      if (scale1.rangeBand) {
        var x = scale1, dx = x.rangeBand() / 2;
        scale0 = scale1 = function(d) {
          return x(d) + dx;
        };
      } else if (scale0.rangeBand) {
        scale0 = scale1;
      } else {
        tickExit.call(tickTransform, scale1, scale0);
      }
      tickEnter.call(tickTransform, scale0, scale1);
      tickUpdate.call(tickTransform, scale1, scale1);
    });
  }
  axis.scale = function(x) {
    if (!arguments.length) return scale;
    scale = x;
    return axis;
  };
  axis.orient = function(x) {
    if (!arguments.length) return orient;
    orient = x in d3_svg_axisOrients ? x + "" : d3_svg_axisDefaultOrient;
    return axis;
  };
  axis.ticks = function() {
    if (!arguments.length) return tickArguments_;
    tickArguments_ = d3_array(arguments);
    return axis;
  };
  axis.tickValues = function(x) {
    if (!arguments.length) return tickValues;
    tickValues = x;
    return axis;
  };
  axis.tickFormat = function(x) {
    if (!arguments.length) return tickFormat_;
    tickFormat_ = x;
    return axis;
  };
  axis.tickSize = function(x) {
    var n = arguments.length;
    if (!n) return innerTickSize;
    innerTickSize = +x;
    outerTickSize = +arguments[n - 1];
    return axis;
  };
  axis.innerTickSize = function(x) {
    if (!arguments.length) return innerTickSize;
    innerTickSize = +x;
    return axis;
  };
  axis.outerTickSize = function(x) {
    if (!arguments.length) return outerTickSize;
    outerTickSize = +x;
    return axis;
  };
  axis.tickPadding = function(x) {
    if (!arguments.length) return tickPadding;
    tickPadding = +x;
    return axis;
  };
  axis.tickSubdivide = function() {
    return arguments.length && axis;
  };
  return axis;
};
var d3_svg_axisDefaultOrient = "bottom", d3_svg_axisOrients = {
  top: 1,
  right: 1,
  bottom: 1,
  left: 1
};
function d3_svg_axisX(selection, x0, x1) {
  selection.attr("transform", function(d) {
    var v0 = x0(d);
    return "translate(" + (isFinite(v0) ? v0 : x1(d)) + ",0)";
  });
}
function d3_svg_axisY(selection, y0, y1) {
  selection.attr("transform", function(d) {
    var v0 = y0(d);
    return "translate(0," + (isFinite(v0) ? v0 : y1(d)) + ")";
  });
}
d3.svg.brush = function() {
  var event = d3_eventDispatch(brush, "brushstart", "brush", "brushend"), x = null, y = null, xExtent = [ 0, 0 ], yExtent = [ 0, 0 ], xExtentDomain, yExtentDomain, xClamp = true, yClamp = true, resizes = d3_svg_brushResizes[0];
  function brush(g) {
    g.each(function() {
      var g = d3.select(this).style("pointer-events", "all").style("-webkit-tap-highlight-color", "rgba(0,0,0,0)").on("mousedown.brush", brushstart).on("touchstart.brush", brushstart);
      var background = g.selectAll(".background").data([ 0 ]);
      background.enter().append("rect").attr("class", "background").style("visibility", "hidden").style("cursor", "crosshair");
      g.selectAll(".extent").data([ 0 ]).enter().append("rect").attr("class", "extent").style("cursor", "move");
      var resize = g.selectAll(".resize").data(resizes, d3_identity);
      resize.exit().remove();
      resize.enter().append("g").attr("class", function(d) {
        return "resize " + d;
      }).style("cursor", function(d) {
        return d3_svg_brushCursor[d];
      }).append("rect").attr("x", function(d) {
        return /[ew]$/.test(d) ? -3 : null;
      }).attr("y", function(d) {
        return /^[ns]/.test(d) ? -3 : null;
      }).attr("width", 6).attr("height", 6).style("visibility", "hidden");
      resize.style("display", brush.empty() ? "none" : null);
      var gUpdate = d3.transition(g), backgroundUpdate = d3.transition(background), range;
      if (x) {
        range = d3_scaleRange(x);
        backgroundUpdate.attr("x", range[0]).attr("width", range[1] - range[0]);
        redrawX(gUpdate);
      }
      if (y) {
        range = d3_scaleRange(y);
        backgroundUpdate.attr("y", range[0]).attr("height", range[1] - range[0]);
        redrawY(gUpdate);
      }
      redraw(gUpdate);
    });
  }
  brush.event = function(g) {
    g.each(function() {
      var event_ = event.of(this, arguments), extent1 = {
        x: xExtent,
        y: yExtent,
        i: xExtentDomain,
        j: yExtentDomain
      }, extent0 = this.__chart__ || extent1;
      this.__chart__ = extent1;
      if (d3_transitionInheritId) {
        d3.select(this).transition().each("start.brush", function() {
          xExtentDomain = extent0.i;
          yExtentDomain = extent0.j;
          xExtent = extent0.x;
          yExtent = extent0.y;
          event_({
            type: "brushstart"
          });
        }).tween("brush:brush", function() {
          var xi = d3_interpolateArray(xExtent, extent1.x), yi = d3_interpolateArray(yExtent, extent1.y);
          xExtentDomain = yExtentDomain = null;
          return function(t) {
            xExtent = extent1.x = xi(t);
            yExtent = extent1.y = yi(t);
            event_({
              type: "brush",
              mode: "resize"
            });
          };
        }).each("end.brush", function() {
          xExtentDomain = extent1.i;
          yExtentDomain = extent1.j;
          event_({
            type: "brush",
            mode: "resize"
          });
          event_({
            type: "brushend"
          });
        });
      } else {
        event_({
          type: "brushstart"
        });
        event_({
          type: "brush",
          mode: "resize"
        });
        event_({
          type: "brushend"
        });
      }
    });
  };
  function redraw(g) {
    g.selectAll(".resize").attr("transform", function(d) {
      return "translate(" + xExtent[+/e$/.test(d)] + "," + yExtent[+/^s/.test(d)] + ")";
    });
  }
  function redrawX(g) {
    g.select(".extent").attr("x", xExtent[0]);
    g.selectAll(".extent,.n>rect,.s>rect").attr("width", xExtent[1] - xExtent[0]);
  }
  function redrawY(g) {
    g.select(".extent").attr("y", yExtent[0]);
    g.selectAll(".extent,.e>rect,.w>rect").attr("height", yExtent[1] - yExtent[0]);
  }
  function brushstart() {
    var target = this, eventTarget = d3.select(d3.event.target), event_ = event.of(target, arguments), g = d3.select(target), resizing = eventTarget.datum(), resizingX = !/^(n|s)$/.test(resizing) && x, resizingY = !/^(e|w)$/.test(resizing) && y, dragging = eventTarget.classed("extent"), dragRestore = d3_event_dragSuppress(target), center, origin = d3.mouse(target), offset;
    var w = d3.select(d3_window(target)).on("keydown.brush", keydown).on("keyup.brush", keyup);
    if (d3.event.changedTouches) {
      w.on("touchmove.brush", brushmove).on("touchend.brush", brushend);
    } else {
      w.on("mousemove.brush", brushmove).on("mouseup.brush", brushend);
    }
    g.interrupt().selectAll("*").interrupt();
    if (dragging) {
      origin[0] = xExtent[0] - origin[0];
      origin[1] = yExtent[0] - origin[1];
    } else if (resizing) {
      var ex = +/w$/.test(resizing), ey = +/^n/.test(resizing);
      offset = [ xExtent[1 - ex] - origin[0], yExtent[1 - ey] - origin[1] ];
      origin[0] = xExtent[ex];
      origin[1] = yExtent[ey];
    } else if (d3.event.altKey) center = origin.slice();
    g.style("pointer-events", "none").selectAll(".resize").style("display", null);
    d3.select("body").style("cursor", eventTarget.style("cursor"));
    event_({
      type: "brushstart"
    });
    brushmove();
    function keydown() {
      if (d3.event.keyCode == 32) {
        if (!dragging) {
          center = null;
          origin[0] -= xExtent[1];
          origin[1] -= yExtent[1];
          dragging = 2;
        }
        d3_eventPreventDefault();
      }
    }
    function keyup() {
      if (d3.event.keyCode == 32 && dragging == 2) {
        origin[0] += xExtent[1];
        origin[1] += yExtent[1];
        dragging = 0;
        d3_eventPreventDefault();
      }
    }
    function brushmove() {
      var point = d3.mouse(target), moved = false;
      if (offset) {
        point[0] += offset[0];
        point[1] += offset[1];
      }
      if (!dragging) {
        if (d3.event.altKey) {
          if (!center) center = [ (xExtent[0] + xExtent[1]) / 2, (yExtent[0] + yExtent[1]) / 2 ];
          origin[0] = xExtent[+(point[0] < center[0])];
          origin[1] = yExtent[+(point[1] < center[1])];
        } else center = null;
      }
      if (resizingX && move1(point, x, 0)) {
        redrawX(g);
        moved = true;
      }
      if (resizingY && move1(point, y, 1)) {
        redrawY(g);
        moved = true;
      }
      if (moved) {
        redraw(g);
        event_({
          type: "brush",
          mode: dragging ? "move" : "resize"
        });
      }
    }
    function move1(point, scale, i) {
      var range = d3_scaleRange(scale), r0 = range[0], r1 = range[1], position = origin[i], extent = i ? yExtent : xExtent, size = extent[1] - extent[0], min, max;
      if (dragging) {
        r0 -= position;
        r1 -= size + position;
      }
      min = (i ? yClamp : xClamp) ? Math.max(r0, Math.min(r1, point[i])) : point[i];
      if (dragging) {
        max = (min += position) + size;
      } else {
        if (center) position = Math.max(r0, Math.min(r1, 2 * center[i] - min));
        if (position < min) {
          max = min;
          min = position;
        } else {
          max = position;
        }
      }
      if (extent[0] != min || extent[1] != max) {
        if (i) yExtentDomain = null; else xExtentDomain = null;
        extent[0] = min;
        extent[1] = max;
        return true;
      }
    }
    function brushend() {
      brushmove();
      g.style("pointer-events", "all").selectAll(".resize").style("display", brush.empty() ? "none" : null);
      d3.select("body").style("cursor", null);
      w.on("mousemove.brush", null).on("mouseup.brush", null).on("touchmove.brush", null).on("touchend.brush", null).on("keydown.brush", null).on("keyup.brush", null);
      dragRestore();
      event_({
        type: "brushend"
      });
    }
  }
  brush.x = function(z) {
    if (!arguments.length) return x;
    x = z;
    resizes = d3_svg_brushResizes[!x << 1 | !y];
    return brush;
  };
  brush.y = function(z) {
    if (!arguments.length) return y;
    y = z;
    resizes = d3_svg_brushResizes[!x << 1 | !y];
    return brush;
  };
  brush.clamp = function(z) {
    if (!arguments.length) return x && y ? [ xClamp, yClamp ] : x ? xClamp : y ? yClamp : null;
    if (x && y) xClamp = !!z[0], yClamp = !!z[1]; else if (x) xClamp = !!z; else if (y) yClamp = !!z;
    return brush;
  };
  brush.extent = function(z) {
    var x0, x1, y0, y1, t;
    if (!arguments.length) {
      if (x) {
        if (xExtentDomain) {
          x0 = xExtentDomain[0], x1 = xExtentDomain[1];
        } else {
          x0 = xExtent[0], x1 = xExtent[1];
          if (x.invert) x0 = x.invert(x0), x1 = x.invert(x1);
          if (x1 < x0) t = x0, x0 = x1, x1 = t;
        }
      }
      if (y) {
        if (yExtentDomain) {
          y0 = yExtentDomain[0], y1 = yExtentDomain[1];
        } else {
          y0 = yExtent[0], y1 = yExtent[1];
          if (y.invert) y0 = y.invert(y0), y1 = y.invert(y1);
          if (y1 < y0) t = y0, y0 = y1, y1 = t;
        }
      }
      return x && y ? [ [ x0, y0 ], [ x1, y1 ] ] : x ? [ x0, x1 ] : y && [ y0, y1 ];
    }
    if (x) {
      x0 = z[0], x1 = z[1];
      if (y) x0 = x0[0], x1 = x1[0];
      xExtentDomain = [ x0, x1 ];
      if (x.invert) x0 = x(x0), x1 = x(x1);
      if (x1 < x0) t = x0, x0 = x1, x1 = t;
      if (x0 != xExtent[0] || x1 != xExtent[1]) xExtent = [ x0, x1 ];
    }
    if (y) {
      y0 = z[0], y1 = z[1];
      if (x) y0 = y0[1], y1 = y1[1];
      yExtentDomain = [ y0, y1 ];
      if (y.invert) y0 = y(y0), y1 = y(y1);
      if (y1 < y0) t = y0, y0 = y1, y1 = t;
      if (y0 != yExtent[0] || y1 != yExtent[1]) yExtent = [ y0, y1 ];
    }
    return brush;
  };
  brush.clear = function() {
    if (!brush.empty()) {
      xExtent = [ 0, 0 ], yExtent = [ 0, 0 ];
      xExtentDomain = yExtentDomain = null;
    }
    return brush;
  };
  brush.empty = function() {
    return !!x && xExtent[0] == xExtent[1] || !!y && yExtent[0] == yExtent[1];
  };
  return d3.rebind(brush, event, "on");
};
var d3_svg_brushCursor = {
  n: "ns-resize",
  e: "ew-resize",
  s: "ns-resize",
  w: "ew-resize",
  nw: "nwse-resize",
  ne: "nesw-resize",
  se: "nwse-resize",
  sw: "nesw-resize"
};
var d3_svg_brushResizes = [ [ "n", "e", "s", "w", "nw", "ne", "se", "sw" ], [ "e", "w" ], [ "n", "s" ], [] ];
var d3_time_format = d3_time.format = d3_locale_enUS.timeFormat;
var d3_time_formatUtc = d3_time_format.utc;
var d3_time_formatIso = d3_time_formatUtc("%Y-%m-%dT%H:%M:%S.%LZ");
d3_time_format.iso = Date.prototype.toISOString && +new Date("2000-01-01T00:00:00.000Z") ? d3_time_formatIsoNative : d3_time_formatIso;
function d3_time_formatIsoNative(date) {
  return date.toISOString();
}
d3_time_formatIsoNative.parse = function(string) {
  var date = new Date(string);
  return isNaN(date) ? null : date;
};
d3_time_formatIsoNative.toString = d3_time_formatIso.toString;
d3_time.second = d3_time_interval(function(date) {
  return new d3_date(Math.floor(date / 1e3) * 1e3);
}, function(date, offset) {
  date.setTime(date.getTime() + Math.floor(offset) * 1e3);
}, function(date) {
  return date.getSeconds();
});
d3_time.seconds = d3_time.second.range;
d3_time.seconds.utc = d3_time.second.utc.range;
d3_time.minute = d3_time_interval(function(date) {
  return new d3_date(Math.floor(date / 6e4) * 6e4);
}, function(date, offset) {
  date.setTime(date.getTime() + Math.floor(offset) * 6e4);
}, function(date) {
  return date.getMinutes();
});
d3_time.minutes = d3_time.minute.range;
d3_time.minutes.utc = d3_time.minute.utc.range;
d3_time.hour = d3_time_interval(function(date) {
  var timezone = date.getTimezoneOffset() / 60;
  return new d3_date((Math.floor(date / 36e5 - timezone) + timezone) * 36e5);
}, function(date, offset) {
  date.setTime(date.getTime() + Math.floor(offset) * 36e5);
}, function(date) {
  return date.getHours();
});
d3_time.hours = d3_time.hour.range;
d3_time.hours.utc = d3_time.hour.utc.range;
d3_time.month = d3_time_interval(function(date) {
  date = d3_time.day(date);
  date.setDate(1);
  return date;
}, function(date, offset) {
  date.setMonth(date.getMonth() + offset);
}, function(date) {
  return date.getMonth();
});
d3_time.months = d3_time.month.range;
d3_time.months.utc = d3_time.month.utc.range;
function d3_time_scale(linear, methods, format) {
  function scale(x) {
    return linear(x);
  }
  scale.invert = function(x) {
    return d3_time_scaleDate(linear.invert(x));
  };
  scale.domain = function(x) {
    if (!arguments.length) return linear.domain().map(d3_time_scaleDate);
    linear.domain(x);
    return scale;
  };
  function tickMethod(extent, count) {
    var span = extent[1] - extent[0], target = span / count, i = d3.bisect(d3_time_scaleSteps, target);
    return i == d3_time_scaleSteps.length ? [ methods.year, d3_scale_linearTickRange(extent.map(function(d) {
      return d / 31536e6;
    }), count)[2] ] : !i ? [ d3_time_scaleMilliseconds, d3_scale_linearTickRange(extent, count)[2] ] : methods[target / d3_time_scaleSteps[i - 1] < d3_time_scaleSteps[i] / target ? i - 1 : i];
  }
  scale.nice = function(interval, skip) {
    var domain = scale.domain(), extent = d3_scaleExtent(domain), method = interval == null ? tickMethod(extent, 10) : typeof interval === "number" && tickMethod(extent, interval);
    if (method) interval = method[0], skip = method[1];
    function skipped(date) {
      return !isNaN(date) && !interval.range(date, d3_time_scaleDate(+date + 1), skip).length;
    }
    return scale.domain(d3_scale_nice(domain, skip > 1 ? {
      floor: function(date) {
        while (skipped(date = interval.floor(date))) date = d3_time_scaleDate(date - 1);
        return date;
      },
      ceil: function(date) {
        while (skipped(date = interval.ceil(date))) date = d3_time_scaleDate(+date + 1);
        return date;
      }
    } : interval));
  };
  scale.ticks = function(interval, skip) {
    var extent = d3_scaleExtent(scale.domain()), method = interval == null ? tickMethod(extent, 10) : typeof interval === "number" ? tickMethod(extent, interval) : !interval.range && [ {
      range: interval
    }, skip ];
    if (method) interval = method[0], skip = method[1];
    return interval.range(extent[0], d3_time_scaleDate(+extent[1] + 1), skip < 1 ? 1 : skip);
  };
  scale.tickFormat = function() {
    return format;
  };
  scale.copy = function() {
    return d3_time_scale(linear.copy(), methods, format);
  };
  return d3_scale_linearRebind(scale, linear);
}
function d3_time_scaleDate(t) {
  return new Date(t);
}
var d3_time_scaleSteps = [ 1e3, 5e3, 15e3, 3e4, 6e4, 3e5, 9e5, 18e5, 36e5, 108e5, 216e5, 432e5, 864e5, 1728e5, 6048e5, 2592e6, 7776e6, 31536e6 ];
var d3_time_scaleLocalMethods = [ [ d3_time.second, 1 ], [ d3_time.second, 5 ], [ d3_time.second, 15 ], [ d3_time.second, 30 ], [ d3_time.minute, 1 ], [ d3_time.minute, 5 ], [ d3_time.minute, 15 ], [ d3_time.minute, 30 ], [ d3_time.hour, 1 ], [ d3_time.hour, 3 ], [ d3_time.hour, 6 ], [ d3_time.hour, 12 ], [ d3_time.day, 1 ], [ d3_time.day, 2 ], [ d3_time.week, 1 ], [ d3_time.month, 1 ], [ d3_time.month, 3 ], [ d3_time.year, 1 ] ];
var d3_time_scaleLocalFormat = d3_time_format.multi([ [ ".%L", function(d) {
  return d.getMilliseconds();
} ], [ ":%S", function(d) {
  return d.getSeconds();
} ], [ "%I:%M", function(d) {
  return d.getMinutes();
} ], [ "%I %p", function(d) {
  return d.getHours();
} ], [ "%a %d", function(d) {
  return d.getDay() && d.getDate() != 1;
} ], [ "%b %d", function(d) {
  return d.getDate() != 1;
} ], [ "%B", function(d) {
  return d.getMonth();
} ], [ "%Y", d3_true ] ]);
var d3_time_scaleMilliseconds = {
  range: function(start, stop, step) {
    return d3.range(Math.ceil(start / step) * step, +stop, step).map(d3_time_scaleDate);
  },
  floor: d3_identity,
  ceil: d3_identity
};
d3_time_scaleLocalMethods.year = d3_time.year;
d3_time.scale = function() {
  return d3_time_scale(d3.scale.linear(), d3_time_scaleLocalMethods, d3_time_scaleLocalFormat);
};
var d3_time_scaleUtcMethods = d3_time_scaleLocalMethods.map(function(m) {
  return [ m[0].utc, m[1] ];
});
var d3_time_scaleUtcFormat = d3_time_formatUtc.multi([ [ ".%L", function(d) {
  return d.getUTCMilliseconds();
} ], [ ":%S", function(d) {
  return d.getUTCSeconds();
} ], [ "%I:%M", function(d) {
  return d.getUTCMinutes();
} ], [ "%I %p", function(d) {
  return d.getUTCHours();
} ], [ "%a %d", function(d) {
  return d.getUTCDay() && d.getUTCDate() != 1;
} ], [ "%b %d", function(d) {
  return d.getUTCDate() != 1;
} ], [ "%B", function(d) {
  return d.getUTCMonth();
} ], [ "%Y", d3_true ] ]);
d3_time_scaleUtcMethods.year = d3_time.year.utc;
d3_time.scale.utc = function() {
  return d3_time_scale(d3.scale.linear(), d3_time_scaleUtcMethods, d3_time_scaleUtcFormat);
};
d3.text = d3_xhrType(function(request) {
  return request.responseText;
});
d3.json = function(url, callback) {
  return d3_xhr(url, "application/json", d3_json, callback);
};
function d3_json(request) {
  return JSON.parse(request.responseText);
}
d3.html = function(url, callback) {
  return d3_xhr(url, "text/html", d3_html, callback);
};
function d3_html(request) {
  var range = d3_document.createRange();
  range.selectNode(d3_document.body);
  return range.createContextualFragment(request.responseText);
}
d3.xml = d3_xhrType(function(request) {
  return request.responseXML;
});
if (true) this.d3 = d3, !(__WEBPACK_AMD_DEFINE_FACTORY__ = (d3),
                              __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
                              (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
                              __WEBPACK_AMD_DEFINE_FACTORY__),
                              __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); else if (typeof module === "object" && module.exports) module.exports = d3; else this.d3 = d3;

}();

/***/ }), /* 30 */ /***/ (function(module, exports, webpack_require) {

(function webpackUniversalModuleDefinition(root, factory) {

if(true)
        module.exports = factory(__webpack_require__(17), __webpack_require__(20));
else if(typeof define === 'function' && define.amd)
        define(["lodash", "graphlib"], factory);
else if(typeof exports === 'object')
        exports["dagre"] = factory(require("lodash"), require("graphlib"));
else
        root["dagre"] = factory(root["lodash"], root["graphlib"]);

})(this, function(WEBPACK_EXTERNAL_MODULE_0, WEBPACK_EXTERNAL_MODULE_2) { return /******/ (function(modules) { // webpackBootstrap /******/ // The module cache /******/ var installedModules = {}; /******/ /******/ // The require function /******/ function webpack_require(moduleId) { /******/ /******/ // Check if module is in cache /******/ if(installedModules) { /******/ return installedModules.exports; /******/ } /******/ // Create a new module (and put it into the cache) /******/ var module = installedModules = { /******/ i: moduleId, /******/ l: false, /******/ exports: {} /******/ }; /******/ /******/ // Execute the module function /******/ modules.call(module.exports, module, module.exports, webpack_require); /******/ /******/ // Flag the module as loaded /******/ module.l = true; /******/ /******/ // Return the exports of the module /******/ return module.exports; /******/ } /******/ /******/ /******/ // expose the modules object (webpack_modules) /******/ webpack_require.m = modules; /******/ /******/ // expose the module cache /******/ webpack_require.c = installedModules; /******/ /******/ // define getter function for harmony exports /******/ webpack_require.d = function(exports, name, getter) { /******/ if(!webpack_require.o(exports, name)) { /******/ Object.defineProperty(exports, name, { /******/ configurable: false, /******/ enumerable: true, /******/ get: getter /******/ }); /******/ } /******/ }; /******/ /******/ // getDefaultExport function for compatibility with non-harmony modules /******/ webpack_require.n = function(module) { /******/ var getter = module && module.__esModule ? /******/ function getDefault() { return module; } : /******/ function getModuleExports() { return module; }; /******/ webpack_require.d(getter, 'a', getter); /******/ return getter; /******/ }; /******/ /******/ // Object.prototype.hasOwnProperty.call /******/ webpack_require.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; /******/ /******/ // webpack_public_path /******/ webpack_require.p = “”; /******/ /******/ // Load entry module and return exports /******/ return webpack_require(_webpack_require_.s = 5); /******/ }) /************************************************************************/ /******/ ([ /* 0 */ /***/ (function(module, exports) {

module.exports = webpack_require(17);

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.addDummyNode = addDummyNode; exports.simplify = simplify; exports.asNonCompoundGraph = asNonCompoundGraph; exports.successorWeights = successorWeights; exports.predecessorWeights = predecessorWeights; exports.intersectRect = intersectRect; exports.buildLayerMatrix = buildLayerMatrix; exports.normalizeRanks = normalizeRanks; exports.removeEmptyRanks = removeEmptyRanks; exports.addBorderNode = addBorderNode; exports.maxRank = maxRank; exports.partition = partition; exports.time = time; exports.notime = notime;

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _graphlib = webpack_require(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* Adds a dummy node to the graph and return v.
*/

function addDummyNode(g, type, attrs, name) {

var v = void 0;
do {
  v = _lodash2.default.uniqueId(name);
} while (g.hasNode(v));

attrs.dummy = type;
g.setNode(v, attrs);
return v;

}

/*

* Returns a new graph with only simple edges. Handles aggregation of data
* associated with multi-edges.
*/

function simplify(g) {

var simplified = new _graphlib.Graph().setGraph(g.graph());
_lodash2.default.each(g.nodes(), function (v) {
  simplified.setNode(v, g.node(v));
});
_lodash2.default.each(g.edges(), function (e) {
  var simpleLabel = simplified.edge(e.v, e.w) || { weight: 0, minlen: 1 };
  var label = g.edge(e);
  simplified.setEdge(e.v, e.w, {
    weight: simpleLabel.weight + label.weight,
    minlen: Math.max(simpleLabel.minlen, label.minlen)
  });
});
return simplified;

}

function asNonCompoundGraph(g) {

var simplified = new _graphlib.Graph({ multigraph: g.isMultigraph() }).setGraph(g.graph());
_lodash2.default.each(g.nodes(), function (v) {
  if (!g.children(v).length) {
    simplified.setNode(v, g.node(v));
  }
});
_lodash2.default.each(g.edges(), function (e) {
  simplified.setEdge(e, g.edge(e));
});
return simplified;

}

function successorWeights(g) {

var weightMap = _lodash2.default.map(g.nodes(), function (v) {
  var sucs = {};
  _lodash2.default.each(g.outEdges(v), function (e) {
    sucs[e.w] = (sucs[e.w] || 0) + g.edge(e).weight;
  });
  return sucs;
});
return _lodash2.default.zipObject(g.nodes(), weightMap);

}

function predecessorWeights(g) {

var weightMap = _lodash2.default.map(g.nodes(), function (v) {
  var preds = {};
  _lodash2.default.each(g.inEdges(v), function (e) {
    preds[e.v] = (preds[e.v] || 0) + g.edge(e).weight;
  });
  return preds;
});
return _lodash2.default.zipObject(g.nodes(), weightMap);

}

/*

* Finds where a line starting at point ({x, y}) would intersect a rectangle
* ({x, y, width, height}) if it were pointing at the rectangle's center.
*/

function intersectRect(rect, point) {

var x = rect.x;
var y = rect.y;

// Rectangle intersection algorithm from:
// http://math.stackexchange.com/questions/108113/find-edge-between-two-boxes
var dx = point.x - x;
var dy = point.y - y;
var w = rect.width / 2;
var h = rect.height / 2;

if (!dx && !dy) {
  throw new Error('Not possible to find intersection inside of the rectangle');
}

var sx = void 0;
var sy = void 0;
if (Math.abs(dy) * w > Math.abs(dx) * h) {
  // Intersection is top or bottom of rect.
  if (dy < 0) {
    h = -h;
  }
  sx = h * dx / dy;
  sy = h;
} else {
  // Intersection is left or right of rect.
  if (dx < 0) {
    w = -w;
  }
  sx = w;
  sy = w * dy / dx;
}

return { x: x + sx, y: y + sy };

}

/*

* Given a DAG with each node assigned "rank" and "order" properties, this
* function will produce a matrix with the ids of each node.
*/

function buildLayerMatrix(g) {

var layering = _lodash2.default.map(_lodash2.default.range(maxRank(g) + 1), function () {
  return [];
});
_lodash2.default.each(g.nodes(), function (v) {
  var node = g.node(v);
  var rank = node.rank;
  if (!_lodash2.default.isUndefined(rank)) {
    layering[rank][node.order] = v;
  }
});
return layering;

}

/*

* Adjusts the ranks for all nodes in the graph such that all nodes v have
* rank(v) >= 0 and at least one node w has rank(w) = 0.
*/

function normalizeRanks(g) {

var min = _lodash2.default.min(_lodash2.default.map(g.nodes(), function (v) {
  return g.node(v).rank;
}));
_lodash2.default.each(g.nodes(), function (v) {
  var node = g.node(v);
  if (_lodash2.default.has(node, 'rank')) {
    node.rank -= min;
  }
});

}

function removeEmptyRanks(g) {

// Ranks may not start at 0, so we need to offset them
var offset = _lodash2.default.min(_lodash2.default.map(g.nodes(), function (v) {
  return g.node(v).rank;
}));

var layers = [];
_lodash2.default.each(g.nodes(), function (v) {
  var rank = g.node(v).rank - offset;
  if (!layers[rank]) {
    layers[rank] = [];
  }
  layers[rank].push(v);
});

var delta = 0;
var nodeRankFactor = g.graph().nodeRankFactor;
_lodash2.default.each(layers, function (vs, i) {
  if (_lodash2.default.isUndefined(vs) && i % nodeRankFactor !== 0) {
    --delta;
  } else if (delta) {
    _lodash2.default.each(vs, function (v) {
      g.node(v).rank += delta;
    });
  }
});

}

function addBorderNode(g, prefix, rank, order) {

var node = {
  width: 0,
  height: 0
};
if (arguments.length >= 4) {
  node.rank = rank;
  node.order = order;
}
return addDummyNode(g, 'border', node, prefix);

}

function maxRank(g) {

return _lodash2.default.max(_lodash2.default.map(g.nodes(), function (v) {
  var rank = g.node(v).rank;
  if (!_lodash2.default.isUndefined(rank)) {
    return rank;
  }
}));

}

/*

* Partition a collection into two groups: `lhs` and `rhs`. If the supplied
* function returns true for an entry it goes into `lhs`. Otherwise it goes
* into `rhs.
*/

function partition(collection, fn) {

var result = { lhs: [], rhs: [] };
_lodash2.default.each(collection, function (value) {
  if (fn(value)) {
    result.lhs.push(value);
  } else {
    result.rhs.push(value);
  }
});
return result;

}

/*

* Returns a new function that wraps `fn` with a timer. The wrapper logs the
* time it takes to execute the function.
*/

function time(name, fn) {

var start = _lodash2.default.now();
try {
  return fn();
} finally {
  console.log(name + ' time: ' + (_lodash2.default.now() - start) + 'ms');
}

}

function notime(name, fn) {

return fn();

}

exports.default = {

addDummyNode: addDummyNode,
simplify: simplify,
asNonCompoundGraph: asNonCompoundGraph,
successorWeights: successorWeights,
predecessorWeights: predecessorWeights,
intersectRect: intersectRect,
buildLayerMatrix: buildLayerMatrix,
normalizeRanks: normalizeRanks,
removeEmptyRanks: removeEmptyRanks,
addBorderNode: addBorderNode,
maxRank: maxRank,
partition: partition,
time: time,
notime: notime

};

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

module.exports = webpack_require(20);

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.longestPath = longestPath; exports.slack = slack;

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* Initializes ranks for the input graph using the longest path algorithm. This
* algorithm scales well and is fast in practice, it yields rather poor
* solutions. Nodes are pushed to the lowest layer possible, leaving the bottom
* ranks wide and leaving edges longer than necessary. However, due to its
* speed, this algorithm is good for getting an initial ranking that can be fed
* into other algorithms.
*
* This algorithm does not normalize layers because it will be used by other
* algorithms in most cases. If using this algorithm directly, be sure to
* run normalize at the end.
*
* Pre-conditions:
*
*    1. Input graph is a DAG.
*    2. Input graph node labels can be assigned properties.
*
* Post-conditions:
*
*    1. Each node will be assign an (unnormalized) "rank" property.
*/

function longestPath(g) {

var visited = {};

function dfs(v) {
  var label = g.node(v);
  if (_lodash2.default.has(visited, v)) {
    return label.rank;
  }
  visited[v] = true;

  var rank = _lodash2.default.min(_lodash2.default.map(g.outEdges(v), function (e) {
    return dfs(e.w) - g.edge(e).minlen;
  })) || 0;

  return label.rank = rank;
}

_lodash2.default.each(g.sources(), dfs);

}

/*

* Returns the amount of slack for the given edge. The slack is defined as the
* difference between the length of the edge and its minimum length.
*/

function slack(g, e) {

return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;

}

exports.default = {

longestPath: longestPath,
slack: slack

};

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _graphlib = webpack_require(2);

var _util = webpack_require(3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* Constructs a spanning tree with tight edges and adjusted the input node's
* ranks to achieve this. A tight edge is one that is has a length that matches
* its "minlen" attribute.
*
* The basic structure for this function is derived from Gansner, et al., "A
* Technique for Drawing Directed Graphs."
*
* Pre-conditions:
*
*    1. Graph must be a DAG.
*    2. Graph must be connected.
*    3. Graph must have at least one node.
*    5. Graph nodes must have been previously assigned a "rank" property that
*       respects the "minlen" property of incident edges.
*    6. Graph edges must have a "minlen" property.
*
* Post-conditions:
*
*    - Graph nodes will have their rank adjusted to ensure that all edges are
*      tight.
*
* Returns a tree (undirected graph) that is constructed using only "tight"
* edges.
*/

function feasibleTree(g) {

var t = new _graphlib.Graph({ directed: false });

// Choose arbitrary node from which to start our tree
var start = g.nodes()[0];
var size = g.nodeCount();
t.setNode(start, {});

var edge = void 0;
var delta = void 0;
while (tightTree(t, g) < size) {
  edge = findMinSlackEdge(t, g);
  delta = t.hasNode(edge.v) ? (0, _util.slack)(g, edge) : -(0, _util.slack)(g, edge);
  shiftRanks(t, g, delta);
}

return t;

}

/*

* Finds a maximal tree of tight edges and returns the number of nodes in the
* tree.
*/

function tightTree(t, g) {

function dfs(v) {
  _lodash2.default.each(g.nodeEdges(v), function (e) {
    var edgeV = e.v;
    var w = v === edgeV ? e.w : edgeV;
    if (!t.hasNode(w) && !(0, _util.slack)(g, e)) {
      t.setNode(w, {});
      t.setEdge(v, w, {});
      dfs(w);
    }
  });
}

_lodash2.default.each(t.nodes(), dfs);
return t.nodeCount();

}

/*

* Finds the edge with the smallest slack that is incident on tree and returns
* it.
*/

function findMinSlackEdge(t, g) {

return _lodash2.default.minBy(g.edges(), function (e) {
  if (t.hasNode(e.v) !== t.hasNode(e.w)) {
    return (0, _util.slack)(g, e);
  }
});

}

function shiftRanks(t, g, delta) {

_lodash2.default.each(t.nodes(), function (v) {
  g.node(v).rank += delta;
});

}

exports.default = feasibleTree;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _graphlib = webpack_require(2);

var _graphlib2 = _interopRequireDefault(_graphlib);

var _layout = webpack_require(6);

var _layout2 = _interopRequireDefault(_layout);

var _debug = webpack_require(28);

var _debug2 = _interopRequireDefault(_debug);

var _util = webpack_require(1);

var _util2 = _interopRequireDefault(_util);

var _package = webpack_require(29);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {

graphlib: _graphlib2.default,
layout: _layout2.default,
debug: _debug2.default,
util: {
  time: _util2.default.time,
  notime: _util2.default.notime
},
version: _package.version

};

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _graphlib = webpack_require(2);

var _acyclic = webpack_require(7);

var _acyclic2 = _interopRequireDefault(_acyclic);

var _normalize = webpack_require(10);

var _normalize2 = _interopRequireDefault(_normalize);

var _rank = webpack_require(11);

var _rank2 = _interopRequireDefault(_rank);

var _util = webpack_require(1);

var _util2 = _interopRequireDefault(_util);

var _parentDummyChains = webpack_require(13);

var _parentDummyChains2 = _interopRequireDefault(_parentDummyChains);

var _nestingGraph = webpack_require(14);

var _nestingGraph2 = _interopRequireDefault(_nestingGraph);

var _addBorderSegments = webpack_require(15);

var _addBorderSegments2 = _interopRequireDefault(_addBorderSegments);

var _coordinateSystem = webpack_require(16);

var _coordinateSystem2 = _interopRequireDefault(_coordinateSystem);

var _order = webpack_require(17);

var _order2 = _interopRequireDefault(_order);

var _position = webpack_require(26);

var _position2 = _interopRequireDefault(_position);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function layout(g, opts) {

var time = opts && opts.debugTiming ? _util2.default.time : _util2.default.notime;
time('layout', function () {
  var layoutGraph = time('  buildLayoutGraph', function () {
    return buildLayoutGraph(g);
  });
  time('  runLayout', function () {
    runLayout(layoutGraph, time);
  });
  time('  updateInputGraph', function () {
    updateInputGraph(g, layoutGraph);
  });
});

}

function runLayout(g, time) {

time('    makeSpaceForEdgeLabels', function () {
  makeSpaceForEdgeLabels(g);
});
time('    removeSelfEdges', function () {
  removeSelfEdges(g);
});
time('    acyclic', function () {
  _acyclic2.default.run(g);
});
time('    nestingGraph.run', function () {
  _nestingGraph2.default.run(g);
});
time('    rank', function () {
  (0, _rank2.default)(_util2.default.asNonCompoundGraph(g));
});
time('    injectEdgeLabelProxies', function () {
  injectEdgeLabelProxies(g);
});
time('    removeEmptyRanks', function () {
  (0, _util.removeEmptyRanks)(g);
});
time('    nestingGraph.cleanup', function () {
  _nestingGraph2.default.cleanup(g);
});
time('    normalizeRanks', function () {
  (0, _util.normalizeRanks)(g);
});
time('    assignRankMinMax', function () {
  assignRankMinMax(g);
});
time('    removeEdgeLabelProxies', function () {
  removeEdgeLabelProxies(g);
});
time('    normalize.run', function () {
  _normalize2.default.run(g);
});
time('    parentDummyChains', function () {
  (0, _parentDummyChains2.default)(g);
});
time('    addBorderSegments', function () {
  (0, _addBorderSegments2.default)(g);
});
time('    order', function () {
  (0, _order2.default)(g);
});
time('    insertSelfEdges', function () {
  insertSelfEdges(g);
});
time('    adjustCoordinateSystem', function () {
  _coordinateSystem2.default.adjust(g);
});
time('    position', function () {
  (0, _position2.default)(g);
});
time('    positionSelfEdges', function () {
  positionSelfEdges(g);
});
time('    removeBorderNodes', function () {
  removeBorderNodes(g);
});
time('    normalize.undo', function () {
  _normalize2.default.undo(g);
});
time('    fixupEdgeLabelCoords', function () {
  fixupEdgeLabelCoords(g);
});
time('    undoCoordinateSystem', function () {
  _coordinateSystem2.default.undo(g);
});
time('    translateGraph', function () {
  translateGraph(g);
});
time('    assignNodeIntersects', function () {
  assignNodeIntersects(g);
});
time('    reversePoints', function () {
  reversePointsForReversedEdges(g);
});
time('    acyclic.undo', function () {
  _acyclic2.default.undo(g);
});

}

/*

* Copies final layout information from the layout graph back to the input
* graph. This process only copies whitelisted attributes from the layout graph
* to the input graph, so it serves as a good place to determine what
* attributes can influence layout.
*/

function updateInputGraph(inputGraph, layoutGraph) {

_lodash2.default.each(inputGraph.nodes(), function (v) {
  var inputLabel = inputGraph.node(v);
  var layoutLabel = layoutGraph.node(v);

  if (inputLabel) {
    inputLabel.x = layoutLabel.x;
    inputLabel.y = layoutLabel.y;

    if (layoutGraph.children(v).length) {
      inputLabel.width = layoutLabel.width;
      inputLabel.height = layoutLabel.height;
    }
  }
});

_lodash2.default.each(inputGraph.edges(), function (e) {
  var inputLabel = inputGraph.edge(e);
  var layoutLabel = layoutGraph.edge(e);

  inputLabel.points = layoutLabel.points;
  if (_lodash2.default.has(layoutLabel, 'x')) {
    inputLabel.x = layoutLabel.x;
    inputLabel.y = layoutLabel.y;
  }
});

inputGraph.graph().width = layoutGraph.graph().width;
inputGraph.graph().height = layoutGraph.graph().height;

}

var graphNumAttrs = ['nodesep', 'edgesep', 'ranksep', 'marginx', 'marginy']; var graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: 'tb' }; var graphAttrs = ['acyclicer', 'ranker', 'rankdir', 'align']; var nodeNumAttrs = ['width', 'height']; var nodeDefaults = { width: 0, height: 0 }; var edgeNumAttrs = ['minlen', 'weight', 'width', 'height', 'labeloffset']; var edgeDefaults = {

minlen: 1,
weight: 1,
width: 0,
height: 0,
labeloffset: 10,
labelpos: 'r'

}; var edgeAttrs = ['labelpos'];

/*

* Constructs a new graph from the input graph, which can be used for layout.
* This process copies only whitelisted attributes from the input graph to the
* layout graph. Thus this function serves as a good place to determine what
* attributes can influence layout.
*/

function buildLayoutGraph(inputGraph) {

var g = new _graphlib.Graph({ multigraph: true, compound: true });
var graph = canonicalize(inputGraph.graph());

g.setGraph(_lodash2.default.merge({}, graphDefaults, selectNumberAttrs(graph, graphNumAttrs), _lodash2.default.pick(graph, graphAttrs)));

_lodash2.default.each(inputGraph.nodes(), function (v) {
  var node = canonicalize(inputGraph.node(v));
  g.setNode(v, _lodash2.default.defaults(selectNumberAttrs(node, nodeNumAttrs), nodeDefaults));
  g.setParent(v, inputGraph.parent(v));
});

_lodash2.default.each(inputGraph.edges(), function (e) {
  var edge = canonicalize(inputGraph.edge(e));
  g.setEdge(e, _lodash2.default.merge({}, edgeDefaults, selectNumberAttrs(edge, edgeNumAttrs), _lodash2.default.pick(edge, edgeAttrs)));
});

return g;

}

/*

* This idea comes from the Gansner paper: to account for edge labels in our
* layout we split each rank in half by doubling minlen and halving ranksep.
* Then we can place labels at these mid-points between nodes.
*
* We also add some minimal padding to the width to push the label for the edge
* away from the edge itself a bit.
*/

function makeSpaceForEdgeLabels(g) {

var graph = g.graph();
graph.ranksep /= 2;
_lodash2.default.each(g.edges(), function (e) {
  var edge = g.edge(e);
  edge.minlen *= 2;
  if (edge.labelpos.toLowerCase() !== 'c') {
    if (graph.rankdir === 'TB' || graph.rankdir === 'BT') {
      edge.width += edge.labeloffset;
    } else {
      edge.height += edge.labeloffset;
    }
  }
});

}

/*

* Creates temporary dummy nodes that capture the rank in which each edge's
* label is going to, if it has one of non-zero width and height. We do this
* so that we can safely remove empty ranks while preserving balance for the
* label's position.
*/

function injectEdgeLabelProxies(g) {

_lodash2.default.each(g.edges(), function (e) {
  var edge = g.edge(e);
  if (edge.width && edge.height) {
    var v = g.node(e.v);
    var w = g.node(e.w);
    var label = { rank: (w.rank - v.rank) / 2 + v.rank, e: e };
    _util2.default.addDummyNode(g, 'edge-proxy', label, '_ep');
  }
});

}

function assignRankMinMax(g) {

var maxRank = 0;
_lodash2.default.each(g.nodes(), function (v) {
  var node = g.node(v);
  if (node.borderTop) {
    node.minRank = g.node(node.borderTop).rank;
    node.maxRank = g.node(node.borderBottom).rank;
    maxRank = Math.max(maxRank, node.maxRank);
  }
});
g.graph().maxRank = maxRank;

}

function removeEdgeLabelProxies(g) {

_lodash2.default.each(g.nodes(), function (v) {
  var node = g.node(v);
  if (node.dummy === 'edge-proxy') {
    g.edge(node.e).labelRank = node.rank;
    g.removeNode(v);
  }
});

}

function translateGraph(g) {

var minX = Number.POSITIVE_INFINITY;
var maxX = 0;
var minY = Number.POSITIVE_INFINITY;
var maxY = 0;
var graphLabel = g.graph();
var marginX = graphLabel.marginx || 0;
var marginY = graphLabel.marginy || 0;

function getExtremes(attrs) {
  var x = attrs.x;
  var y = attrs.y;
  var w = attrs.width;
  var h = attrs.height;
  minX = Math.min(minX, x - w / 2);
  maxX = Math.max(maxX, x + w / 2);
  minY = Math.min(minY, y - h / 2);
  maxY = Math.max(maxY, y + h / 2);
}

_lodash2.default.each(g.nodes(), function (v) {
  getExtremes(g.node(v));
});
_lodash2.default.each(g.edges(), function (e) {
  var edge = g.edge(e);
  if (_lodash2.default.has(edge, 'x')) {
    getExtremes(edge);
  }
});

minX -= marginX;
minY -= marginY;

_lodash2.default.each(g.nodes(), function (v) {
  var node = g.node(v);
  node.x -= minX;
  node.y -= minY;
});

_lodash2.default.each(g.edges(), function (e) {
  var edge = g.edge(e);
  _lodash2.default.each(edge.points, function (p) {
    p.x -= minX;
    p.y -= minY;
  });
  if (_lodash2.default.has(edge, 'x')) {
    edge.x -= minX;
  }
  if (_lodash2.default.has(edge, 'y')) {
    edge.y -= minY;
  }
});

graphLabel.width = maxX - minX + marginX;
graphLabel.height = maxY - minY + marginY;

}

function assignNodeIntersects(g) {

_lodash2.default.each(g.edges(), function (e) {
  var edge = g.edge(e);
  var nodeV = g.node(e.v);
  var nodeW = g.node(e.w);
  var p1 = null;
  var p2 = null;
  if (!edge.points) {
    edge.points = [];
    p1 = nodeW;
    p2 = nodeV;
  } else {
    p1 = edge.points[0];
    p2 = edge.points[edge.points.length - 1];
  }
  edge.points.unshift(_util2.default.intersectRect(nodeV, p1));
  edge.points.push(_util2.default.intersectRect(nodeW, p2));
});

}

function fixupEdgeLabelCoords(g) {

_lodash2.default.each(g.edges(), function (e) {
  var edge = g.edge(e);
  if (_lodash2.default.has(edge, 'x')) {
    if (edge.labelpos === 'l' || edge.labelpos === 'r') {
      edge.width -= edge.labeloffset;
    }
    switch (edge.labelpos) {
      case 'l':
        edge.x -= edge.width / 2 + edge.labeloffset;break;
      case 'r':
        edge.x += edge.width / 2 + edge.labeloffset;break;
    }
  }
});

}

function reversePointsForReversedEdges(g) {

_lodash2.default.each(g.edges(), function (e) {
  var edge = g.edge(e);
  if (edge.reversed) {
    edge.points.reverse();
  }
});

}

function removeBorderNodes(g) {

_lodash2.default.each(g.nodes(), function (v) {
  if (g.children(v).length) {
    var node = g.node(v);
    var t = g.node(node.borderTop);
    var b = g.node(node.borderBottom);
    var l = g.node(_lodash2.default.last(node.borderLeft));
    var r = g.node(_lodash2.default.last(node.borderRight));

    node.width = Math.abs(r.x - l.x);
    node.height = Math.abs(b.y - t.y);
    node.x = l.x + node.width / 2;
    node.y = t.y + node.height / 2;
  }
});

_lodash2.default.each(g.nodes(), function (v) {
  if (g.node(v).dummy === 'border') {
    g.removeNode(v);
  }
});

}

function removeSelfEdges(g) {

_lodash2.default.each(g.edges(), function (e) {
  if (e.v === e.w) {
    var node = g.node(e.v);
    if (!node.selfEdges) {
      node.selfEdges = [];
    }
    node.selfEdges.push({ e: e, label: g.edge(e) });
    g.removeEdge(e);
  }
});

}

function insertSelfEdges(g) {

var layers = _util2.default.buildLayerMatrix(g);
_lodash2.default.each(layers, function (layer) {
  var orderShift = 0;
  _lodash2.default.each(layer, function (v, i) {
    var node = g.node(v);
    node.order = i + orderShift;
    _lodash2.default.each(node.selfEdges, function (selfEdge) {
      _util2.default.addDummyNode(g, 'selfedge', {
        width: selfEdge.label.width,
        height: selfEdge.label.height,
        rank: node.rank,
        order: i + ++orderShift,
        e: selfEdge.e,
        label: selfEdge.label
      }, '_se');
    });
    delete node.selfEdges;
  });
});

}

function positionSelfEdges(g) {

_lodash2.default.each(g.nodes(), function (v) {
  var node = g.node(v);
  if (node.dummy === 'selfedge') {
    var selfNode = g.node(node.e.v);
    var x = selfNode.x + selfNode.width / 2;
    var y = selfNode.y;
    var dx = node.x - x;
    var dy = selfNode.height / 2;
    g.setEdge(node.e, node.label);
    g.removeNode(v);
    node.label.points = [{ x: x + 2 * dx / 3, y: y - dy }, { x: x + 5 * dx / 6, y: y - dy }, { x: x + dx, y: y }, { x: x + 5 * dx / 6, y: y + dy }, { x: x + 2 * dx / 3, y: y + dy }];
    node.label.x = node.x;
    node.label.y = node.y;
  }
});

}

function selectNumberAttrs(obj, attrs) {

return _lodash2.default.mapValues(_lodash2.default.pick(obj, attrs), Number);

}

function canonicalize(attrs) {

var newAttrs = {};
_lodash2.default.each(attrs, function (v, k) {
  newAttrs[k.toLowerCase()] = v;
});
return newAttrs;

}

exports.default = layout;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _greedyFas = webpack_require(8);

var _greedyFas2 = _interopRequireDefault(_greedyFas);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function run(g) {

var fas = g.graph().acyclicer === 'greedy' ? (0, _greedyFas2.default)(g, weightFn(g)) : dfsFAS(g);
_lodash2.default.each(fas, function (e) {
  var label = g.edge(e);
  g.removeEdge(e);
  label.forwardName = e.name;
  label.reversed = true;
  g.setEdge(e.w, e.v, label, _lodash2.default.uniqueId('rev'));
});

function weightFn(g) {
  return function (e) {
    return g.edge(e).weight;
  };
}

}

function dfsFAS(g) {

var fas = [];
var stack = {};
var visited = {};

function dfs(v) {
  if (_lodash2.default.has(visited, v)) {
    return;
  }
  visited[v] = true;
  stack[v] = true;
  _lodash2.default.each(g.outEdges(v), function (e) {
    if (_lodash2.default.has(stack, e.w)) {
      fas.push(e);
    } else {
      dfs(e.w);
    }
  });
  delete stack[v];
}

_lodash2.default.each(g.nodes(), dfs);
return fas;

}

function undo(g) {

_lodash2.default.each(g.edges(), function (e) {
  var label = g.edge(e);
  if (label.reversed) {
    g.removeEdge(e);

    var forwardName = label.forwardName;
    delete label.reversed;
    delete label.forwardName;
    g.setEdge(e.w, e.v, label, forwardName);
  }
});

}

exports.default = {

run: run,
undo: undo

};

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _graphlib = webpack_require(2);

var _list = webpack_require(9);

var _list2 = _interopRequireDefault(_list);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* A greedy heuristic for finding a feedback arc set for a graph. A feedback
* arc set is a set of edges that can be removed to make a graph acyclic.
* The algorithm comes from: P. Eades, X. Lin, and W. F. Smyth, "A fast and
* effective heuristic for the feedback arc set problem." This implementation
* adjusts that from the paper to allow for weighted edges.
*/

var DEFAULT_WEIGHT_FN = _lodash2.default.constant(1);

function greedyFAS(g, weightFn) {

if (g.nodeCount() <= 1) {
  return [];
}
var state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);
var results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);

// Expand multi-edges
return _lodash2.default.flatten(_lodash2.default.map(results, function (e) {
  return g.outEdges(e.v, e.w);
}), true);

}

function doGreedyFAS(g, buckets, zeroIdx) {

var results = [];
var sources = buckets[buckets.length - 1];
var sinks = buckets[0];

var entry = void 0;
while (g.nodeCount()) {
  while (entry = sinks.dequeue()) {
    removeNode(g, buckets, zeroIdx, entry);
  }
  while (entry = sources.dequeue()) {
    removeNode(g, buckets, zeroIdx, entry);
  }
  if (g.nodeCount()) {
    for (var i = buckets.length - 2; i > 0; --i) {
      entry = buckets[i].dequeue();
      if (entry) {
        results = results.concat(removeNode(g, buckets, zeroIdx, entry, true));
        break;
      }
    }
  }
}

return results;

}

function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {

var results = collectPredecessors ? [] : undefined;

_lodash2.default.each(g.inEdges(entry.v), function (edge) {
  var weight = g.edge(edge);
  var uEntry = g.node(edge.v);

  if (collectPredecessors) {
    results.push({ v: edge.v, w: edge.w });
  }

  uEntry.out -= weight;
  assignBucket(buckets, zeroIdx, uEntry);
});

_lodash2.default.each(g.outEdges(entry.v), function (edge) {
  var weight = g.edge(edge);
  var w = edge.w;
  var wEntry = g.node(w);
  wEntry['in'] -= weight;
  assignBucket(buckets, zeroIdx, wEntry);
});

g.removeNode(entry.v);

return results;

}

function buildState(g, weightFn) {

var fasGraph = new _graphlib.Graph();
var maxIn = 0;
var maxOut = 0;

_lodash2.default.each(g.nodes(), function (v) {
  fasGraph.setNode(v, { v: v, 'in': 0, out: 0 });
});

// Aggregate weights on nodes, but also sum the weights across multi-edges
// into a single edge for the fasGraph.
_lodash2.default.each(g.edges(), function (e) {
  var prevWeight = fasGraph.edge(e.v, e.w) || 0;
  var weight = weightFn(e);
  var edgeWeight = prevWeight + weight;
  fasGraph.setEdge(e.v, e.w, edgeWeight);
  maxOut = Math.max(maxOut, fasGraph.node(e.v).out += weight);
  maxIn = Math.max(maxIn, fasGraph.node(e.w)['in'] += weight);
});

var buckets = _lodash2.default.range(maxOut + maxIn + 3).map(function () {
  return new _list2.default();
});
var zeroIdx = maxIn + 1;

_lodash2.default.each(fasGraph.nodes(), function (v) {
  assignBucket(buckets, zeroIdx, fasGraph.node(v));
});

return { graph: fasGraph, buckets: buckets, zeroIdx: zeroIdx };

}

function assignBucket(buckets, zeroIdx, entry) {

if (!entry.out) {
  buckets[0].enqueue(entry);
} else if (!entry['in']) {
  buckets[buckets.length - 1].enqueue(entry);
} else {
  buckets[entry.out - entry['in'] + zeroIdx].enqueue(entry);
}

}

exports.default = greedyFAS;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); /*

* Simple doubly linked list implementation derived from Cormen, et al.,
* "Introduction to Algorithms".
*/

function List() {

var sentinel = {};
sentinel._next = sentinel._prev = sentinel;
this._sentinel = sentinel;

}

List.prototype.dequeue = function () {

var sentinel = this._sentinel;
var entry = sentinel._prev;
if (entry !== sentinel) {
  unlink(entry);
  return entry;
}

};

List.prototype.enqueue = function (entry) {

var sentinel = this._sentinel;
if (entry._prev && entry._next) {
  unlink(entry);
}
entry._next = sentinel._next;
sentinel._next._prev = entry;
sentinel._next = entry;
entry._prev = sentinel;

};

List.prototype.toString = function () {

var strs = [];
var sentinel = this._sentinel;
var curr = sentinel._prev;
while (curr !== sentinel) {
  strs.push(JSON.stringify(curr, filterOutLinks));
  curr = curr._prev;
}
return '[' + strs.join(', ') + ']';

};

function unlink(entry) {

entry._prev._next = entry._next;
entry._next._prev = entry._prev;
delete entry._next;
delete entry._prev;

}

function filterOutLinks(k, v) {

if (k !== '_next' && k !== '_prev') {
  return v;
}

}

exports.default = List;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _util = webpack_require(1);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* Breaks any long edges in the graph into short segments that span 1 layer
* each. This operation is undoable with the denormalize function.
*
* Pre-conditions:
*
*    1. The input graph is a DAG.
*    2. Each node in the graph has a "rank" property.
*
* Post-condition:
*
*    1. All edges in the graph have a length of 1.
*    2. Dummy nodes are added where edges have been split into segments.
*    3. The graph is augmented with a "dummyChains" attribute which contains
*       the first dummy in each chain of dummy nodes produced.
*/

function run(g) {

g.graph().dummyChains = [];
_lodash2.default.each(g.edges(), function (edge) {
  normalizeEdge(g, edge);
});

}

function normalizeEdge(g, e) {

var v = e.v;
var vRank = g.node(v).rank;
var w = e.w;
var wRank = g.node(w).rank;
var name = e.name;
var edgeLabel = g.edge(e);
var labelRank = edgeLabel.labelRank;

if (wRank === vRank + 1) return;

g.removeEdge(e);

var dummy = void 0;
var attrs = void 0;
var i = void 0;
for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {
  edgeLabel.points = [];
  attrs = {
    width: 0,
    height: 0,
    edgeLabel: edgeLabel,
    edgeObj: e,
    rank: vRank
  };
  dummy = _util2.default.addDummyNode(g, 'edge', attrs, '_d');
  if (vRank === labelRank) {
    attrs.width = edgeLabel.width;
    attrs.height = edgeLabel.height;
    attrs.dummy = 'edge-label';
    attrs.labelpos = edgeLabel.labelpos;
  }
  g.setEdge(v, dummy, { weight: edgeLabel.weight }, name);
  if (i === 0) {
    g.graph().dummyChains.push(dummy);
  }
  v = dummy;
}

g.setEdge(v, w, { weight: edgeLabel.weight }, name);

}

function undo(g) {

_lodash2.default.each(g.graph().dummyChains, function (v) {
  var node = g.node(v);
  var origLabel = node.edgeLabel;
  var w = null;
  g.setEdge(node.edgeObj, origLabel);
  while (node.dummy) {
    w = g.successors(v)[0];
    g.removeNode(v);
    origLabel.points.push({ x: node.x, y: node.y });
    if (node.dummy === 'edge-label') {
      origLabel.x = node.x;
      origLabel.y = node.y;
      origLabel.width = node.width;
      origLabel.height = node.height;
    }
    v = w;
    node = g.node(v);
  }
});

}

exports.default = {

run: run,
undo: undo

};

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _util = webpack_require(3);

var _feasibleTree = webpack_require(4);

var _feasibleTree2 = _interopRequireDefault(_feasibleTree);

var _networkSimplex = webpack_require(12);

var _networkSimplex2 = _interopRequireDefault(_networkSimplex);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* Assigns a rank to each node in the input graph that respects the "minlen"
* constraint specified on edges between nodes.
*
* This basic structure is derived from Gansner, et al., "A Technique for
* Drawing Directed Graphs."
*
* Pre-conditions:
*
*    1. Graph must be a connected DAG
*    2. Graph nodes must be objects
*    3. Graph edges must have "weight" and "minlen" attributes
*
* Post-conditions:
*
*    1. Graph nodes will have a "rank" attribute based on the results of the
*       algorithm. Ranks can start at any index (including negative), we'll
*       fix them up later.
*/

function rank(g) {

switch (g.graph().ranker) {
  case 'network-simplex':
    networkSimplexRanker(g);break;
  case 'tight-tree':
    tightTreeRanker(g);break;
  case 'longest-path':
    longestPathRanker(g);break;
  default:
    networkSimplexRanker(g);
}

}

// A fast and simple ranker, but results are far from optimal. var longestPathRanker = _util.longestPath;

function tightTreeRanker(g) {

(0, _util.longestPath)(g);
(0, _feasibleTree2.default)(g);

}

function networkSimplexRanker(g) {

(0, _networkSimplex2.default)(g);

}

exports.default = rank;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _graphlib = webpack_require(2);

var _feasibleTree = webpack_require(4);

var _feasibleTree2 = _interopRequireDefault(_feasibleTree);

var _util = webpack_require(3);

var _util2 = webpack_require(1);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var preorder = _graphlib.alg.preorder,

postorder = _graphlib.alg.postorder;

// Expose some internals for testing purposes

networkSimplex.initLowLimValues = initLowLimValues; networkSimplex.initCutValues = initCutValues; networkSimplex.calcCutValue = calcCutValue; networkSimplex.leaveEdge = leaveEdge; networkSimplex.enterEdge = enterEdge; networkSimplex.exchangeEdges = exchangeEdges;

/*

* The network simplex algorithm assigns ranks to each node in the input graph
* and iteratively improves the ranking to reduce the length of edges.
*
* Preconditions:
*
*    1. The input graph must be a DAG.
*    2. All nodes in the graph must have an object value.
*    3. All edges in the graph must have "minlen" and "weight" attributes.
*
* Postconditions:
*
*    1. All nodes in the graph will have an assigned "rank" attribute that has
*       been optimized by the network simplex algorithm. Ranks start at 0.
*
*
* A rough sketch of the algorithm is as follows:
*
*    1. Assign initial ranks to each node. We use the longest path algorithm,
*       which assigns ranks to the lowest position possible. In general this
*       leads to very wide bottom ranks and unnecessarily long edges.
*    2. Construct a feasible tight tree. A tight tree is one such that all
*       edges in the tree have no slack (difference between length of edge
*       and minlen for the edge). This by itself greatly improves the assigned
*       rankings by shorting edges.
*    3. Iteratively find edges that have negative cut values. Generally a
*       negative cut value indicates that the edge could be removed and a new
*       tree edge could be added to produce a more compact graph.
*
* Much of the algorithms here are derived from Gansner, et al., "A Technique
* for Drawing Directed Graphs." The structure of the file roughly follows the
* structure of the overall algorithm.
*/

function networkSimplex(g) {

g = (0, _util2.simplify)(g);
(0, _util.longestPath)(g);
var t = (0, _feasibleTree2.default)(g);
initLowLimValues(t);
initCutValues(t, g);

var e = void 0;
var f = void 0;
while (e = leaveEdge(t)) {
  f = enterEdge(t, g, e);
  exchangeEdges(t, g, e, f);
}

}

/*

* Initializes cut values for all edges in the tree.
*/

function initCutValues(t, g) {

var vs = postorder(t, t.nodes());
vs = vs.slice(0, vs.length - 1);
_lodash2.default.each(vs, function (v) {
  assignCutValue(t, g, v);
});

}

function assignCutValue(t, g, child) {

var childLab = t.node(child);
var parent = childLab.parent;
t.edge(child, parent).cutvalue = calcCutValue(t, g, child);

}

/*

* Given the tight tree, its graph, and a child in the graph calculate and
* return the cut value for the edge between the child and its parent.
*/

function calcCutValue(t, g, child) {

var childLab = t.node(child);
var parent = childLab.parent;
// True if the child is on the tail end of the edge in the directed graph
var childIsTail = true;
// The graph's view of the tree edge we're inspecting
var graphEdge = g.edge(child, parent);
// The accumulated cut value for the edge between this node and its parent
var cutValue = 0;

if (!graphEdge) {
  childIsTail = false;
  graphEdge = g.edge(parent, child);
}

cutValue = graphEdge.weight;

_lodash2.default.each(g.nodeEdges(child), function (e) {
  var isOutEdge = e.v === child;
  var other = isOutEdge ? e.w : e.v;

  if (other !== parent) {
    var pointsToHead = isOutEdge === childIsTail;
    var otherWeight = g.edge(e).weight;

    cutValue += pointsToHead ? otherWeight : -otherWeight;
    if (isTreeEdge(t, child, other)) {
      var otherCutValue = t.edge(child, other).cutvalue;
      cutValue += pointsToHead ? -otherCutValue : otherCutValue;
    }
  }
});

return cutValue;

}

function initLowLimValues(tree, root) {

if (arguments.length < 2) {
  root = tree.nodes()[0];
}
dfsAssignLowLim(tree, {}, 1, root);

}

function dfsAssignLowLim(tree, visited, nextLim, v, parent) {

var low = nextLim;
var label = tree.node(v);

visited[v] = true;
_lodash2.default.each(tree.neighbors(v), function (w) {
  if (!_lodash2.default.has(visited, w)) {
    nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
  }
});

label.low = low;
label.lim = nextLim++;
if (parent) {
  label.parent = parent;
} else {
  // TODO should be able to remove this when we incrementally update low lim
  delete label.parent;
}

return nextLim;

}

function leaveEdge(tree) {

return _lodash2.default.find(tree.edges(), function (e) {
  return tree.edge(e).cutvalue < 0;
});

}

function enterEdge(t, g, edge) {

var v = edge.v;
var w = edge.w;

// For the rest of this function we assume that v is the tail and w is the
// head, so if we don't have this edge in the graph we should flip it to
// match the correct orientation.
if (!g.hasEdge(v, w)) {
  v = edge.w;
  w = edge.v;
}

var vLabel = t.node(v);
var wLabel = t.node(w);
var tailLabel = vLabel;
var flip = false;

// If the root is in the tail of the edge then we need to flip the logic that
// checks for the head and tail nodes in the candidates function below.
if (vLabel.lim > wLabel.lim) {
  tailLabel = wLabel;
  flip = true;
}

var candidates = _lodash2.default.filter(g.edges(), function (edge) {
  return flip === isDescendant(t, t.node(edge.v), tailLabel) && flip !== isDescendant(t, t.node(edge.w), tailLabel);
});

return _lodash2.default.minBy(candidates, function (edge) {
  return (0, _util.slack)(g, edge);
});

}

function exchangeEdges(t, g, e, f) {

var v = e.v;
var w = e.w;
t.removeEdge(v, w);
t.setEdge(f.v, f.w, {});
initLowLimValues(t);
initCutValues(t, g);
updateRanks(t, g);

}

function updateRanks(t, g) {

var root = _lodash2.default.find(t.nodes(), function (v) {
  return !g.node(v).parent;
});
var vs = preorder(t, root);
vs = vs.slice(1);
_lodash2.default.each(vs, function (v) {
  var parent = t.node(v).parent;
  var edge = g.edge(v, parent);
  var flipped = false;

  if (!edge) {
    edge = g.edge(parent, v);
    flipped = true;
  }

  g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);
});

}

/*

* Returns true if the edge is in the tree.
*/

function isTreeEdge(tree, u, v) {

return tree.hasEdge(u, v);

}

/*

* Returns true if the specified node is descendant of the root node per the
* assigned low and lim attributes in the tree.
*/

function isDescendant(tree, vLabel, rootLabel) {

return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;

}

exports.default = networkSimplex;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function parentDummyChains(g) {

var postorderNums = postorder(g);

_lodash2.default.each(g.graph().dummyChains, function (v) {
  var node = g.node(v);
  var edgeObj = node.edgeObj;
  var pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
  var path = pathData.path;
  var lca = pathData.lca;
  var pathIdx = 0;
  var pathV = path[pathIdx];
  var ascending = true;

  while (v !== edgeObj.w) {
    node = g.node(v);

    if (ascending) {
      while ((pathV = path[pathIdx]) !== lca && g.node(pathV).maxRank < node.rank) {
        pathIdx++;
      }

      if (pathV === lca) {
        ascending = false;
      }
    }

    if (!ascending) {
      while (pathIdx < path.length - 1 && g.node(pathV = path[pathIdx + 1]).minRank <= node.rank) {
        pathIdx++;
      }
      pathV = path[pathIdx];
    }

    g.setParent(v, pathV);
    v = g.successors(v)[0];
  }
});

}

// Find a path from v to w through the lowest common ancestor (LCA). Return the // full path and the LCA. function findPath(g, postorderNums, v, w) {

var vPath = [];
var wPath = [];
var low = Math.min(postorderNums[v].low, postorderNums[w].low);
var lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);
var parent = void 0;
var lca = void 0;

// Traverse up from v to find the LCA
parent = v;
do {
  parent = g.parent(parent);
  vPath.push(parent);
} while (parent && (postorderNums[parent].low > low || lim > postorderNums[parent].lim));
lca = parent;

// Traverse from w to LCA
parent = w;
while ((parent = g.parent(parent)) !== lca) {
  wPath.push(parent);
}

return { path: vPath.concat(wPath.reverse()), lca: lca };

}

function postorder(g) {

var result = {};
var lim = 0;

function dfs(v) {
  var low = lim;
  _lodash2.default.each(g.children(v), dfs);
  result[v] = { low: low, lim: lim++ };
}
_lodash2.default.each(g.children(), dfs);

return result;

}

exports.default = parentDummyChains;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _util = webpack_require(1);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* A nesting graph creates dummy nodes for the tops and bottoms of subgraphs,
* adds appropriate edges to ensure that all cluster nodes are placed between
* these boundries, and ensures that the graph is connected.
*
* In addition we ensure, through the use of the minlen property, that nodes
* and subgraph border nodes to not end up on the same rank.
*
* Preconditions:
*
*    1. Input graph is a DAG
*    2. Nodes in the input graph has a minlen attribute
*
* Postconditions:
*
*    1. Input graph is connected.
*    2. Dummy nodes are added for the tops and bottoms of subgraphs.
*    3. The minlen attribute for nodes is adjusted to ensure nodes do not
*       get placed on the same rank as subgraph border nodes.
*
* The nesting graph idea comes from Sander, "Layout of Compound Directed
* Graphs."
*/

function run(g) {

var root = _util2.default.addDummyNode(g, 'root', {}, '_root');
var depths = treeDepths(g);
var height = _lodash2.default.max(_lodash2.default.values(depths)) - 1;
var nodeSep = 2 * height + 1;

g.graph().nestingRoot = root;

// Multiply minlen by nodeSep to align nodes on non-border ranks.
_lodash2.default.each(g.edges(), function (e) {
  g.edge(e).minlen *= nodeSep;
});

// Calculate a weight that is sufficient to keep subgraphs vertically compact
var weight = sumWeights(g) + 1;

// Create border nodes and link them up
_lodash2.default.each(g.children(), function (child) {
  dfs(g, root, nodeSep, weight, height, depths, child);
});

// Save the multiplier for node layers for later removal of empty border
// layers.
g.graph().nodeRankFactor = nodeSep;

}

function dfs(g, root, nodeSep, weight, height, depths, v) {

var children = g.children(v);
if (!children.length) {
  if (v !== root) {
    g.setEdge(root, v, { weight: 0, minlen: nodeSep });
  }
  return;
}

var top = _util2.default.addBorderNode(g, '_bt');
var bottom = _util2.default.addBorderNode(g, '_bb');
var label = g.node(v);

g.setParent(top, v);
label.borderTop = top;
g.setParent(bottom, v);
label.borderBottom = bottom;

_lodash2.default.each(children, function (child) {
  dfs(g, root, nodeSep, weight, height, depths, child);

  var childNode = g.node(child);
  var childTop = childNode.borderTop ? childNode.borderTop : child;
  var childBottom = childNode.borderBottom ? childNode.borderBottom : child;
  var thisWeight = childNode.borderTop ? weight : 2 * weight;
  var minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;

  g.setEdge(top, childTop, {
    weight: thisWeight,
    minlen: minlen,
    nestingEdge: true
  });

  g.setEdge(childBottom, bottom, {
    weight: thisWeight,
    minlen: minlen,
    nestingEdge: true
  });
});

if (!g.parent(v)) {
  g.setEdge(root, top, { weight: 0, minlen: height + depths[v] });
}

}

function treeDepths(g) {

var depths = {};
function dfs(v, depth) {
  var children = g.children(v);
  if (children && children.length) {
    _lodash2.default.each(children, function (child) {
      dfs(child, depth + 1);
    });
  }
  depths[v] = depth;
}
_lodash2.default.each(g.children(), function (v) {
  dfs(v, 1);
});
return depths;

}

function sumWeights(g) {

return _lodash2.default.reduce(g.edges(), function (acc, e) {
  return acc + g.edge(e).weight;
}, 0);

}

function cleanup(g) {

var graphLabel = g.graph();
g.removeNode(graphLabel.nestingRoot);
delete graphLabel.nestingRoot;
_lodash2.default.each(g.edges(), function (e) {
  var edge = g.edge(e);
  if (edge.nestingEdge) {
    g.removeEdge(e);
  }
});

}

exports.default = {

run: run,
cleanup: cleanup

};

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _util = webpack_require(1);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function addBorderSegments(g) {

function dfs(v) {
  var children = g.children(v);
  var node = g.node(v);
  if (children.length) {
    _lodash2.default.each(children, dfs);
  }

  if (_lodash2.default.has(node, 'minRank')) {
    node.borderLeft = [];
    node.borderRight = [];
    for (var rank = node.minRank, maxRank = node.maxRank + 1; rank < maxRank; ++rank) {
      addBorderNode(g, 'borderLeft', '_bl', v, node, rank);
      addBorderNode(g, 'borderRight', '_br', v, node, rank);
    }
  }
}

_lodash2.default.each(g.children(), dfs);

}

function addBorderNode(g, prop, prefix, sg, sgNode, rank) {

var label = { width: 0, height: 0, rank: rank, borderType: prop };
var prev = sgNode[prop][rank - 1];
var curr = _util2.default.addDummyNode(g, 'border', label, prefix);
sgNode[prop][rank] = curr;
g.setParent(curr, sg);
if (prev) {
  g.setEdge(prev, curr, { weight: 1 });
}

}

exports.default = addBorderSegments;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function adjust(g) {

var rankDir = g.graph().rankdir.toLowerCase();
if (rankDir === 'lr' || rankDir === 'rl') {
  swapWidthHeight(g);
}

}

function undo(g) {

var rankDir = g.graph().rankdir.toLowerCase();
if (rankDir === 'bt' || rankDir === 'rl') {
  reverseY(g);
}

if (rankDir === 'lr' || rankDir === 'rl') {
  swapXY(g);
  swapWidthHeight(g);
}

}

function swapWidthHeight(g) {

_lodash2.default.each(g.nodes(), function (v) {
  swapWidthHeightOne(g.node(v));
});
_lodash2.default.each(g.edges(), function (e) {
  swapWidthHeightOne(g.edge(e));
});

}

function swapWidthHeightOne(attrs) {

var w = attrs.width;
attrs.width = attrs.height;
attrs.height = w;

}

function reverseY(g) {

_lodash2.default.each(g.nodes(), function (v) {
  reverseYOne(g.node(v));
});

_lodash2.default.each(g.edges(), function (e) {
  var edge = g.edge(e);
  _lodash2.default.each(edge.points, reverseYOne);
  if (_lodash2.default.has(edge, 'y')) {
    reverseYOne(edge);
  }
});

}

function reverseYOne(attrs) {

attrs.y = -attrs.y;

}

function swapXY(g) {

_lodash2.default.each(g.nodes(), function (v) {
  swapXYOne(g.node(v));
});

_lodash2.default.each(g.edges(), function (e) {
  var edge = g.edge(e);
  _lodash2.default.each(edge.points, swapXYOne);
  if (_lodash2.default.has(edge, 'x')) {
    swapXYOne(edge);
  }
});

}

function swapXYOne(attrs) {

var x = attrs.x;
attrs.x = attrs.y;
attrs.y = x;

}

exports.default = {

adjust: adjust,
undo: undo

};

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _graphlib = webpack_require(2);

var _initOrder = webpack_require(18);

var _initOrder2 = _interopRequireDefault(_initOrder);

var _crossCount = webpack_require(19);

var _crossCount2 = _interopRequireDefault(_crossCount);

var _sortSubgraph = webpack_require(20);

var _sortSubgraph2 = _interopRequireDefault(_sortSubgraph);

var _buildLayerGraph = webpack_require(24);

var _buildLayerGraph2 = _interopRequireDefault(_buildLayerGraph);

var _addSubgraphConstraints = webpack_require(25);

var _addSubgraphConstraints2 = _interopRequireDefault(_addSubgraphConstraints);

var _util = webpack_require(1);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* Applies heuristics to minimize edge crossings in the graph and sets the best
* order solution as an order attribute on each node.
*
* Pre-conditions:
*
*    1. Graph must be DAG
*    2. Graph nodes must be objects with a "rank" attribute
*    3. Graph edges must have the "weight" attribute
*
* Post-conditions:
*
*    1. Graph nodes will have an "order" attribute based on the results of the
*       algorithm.
*/

function order(g) {

var maxRank = _util2.default.maxRank(g);
var downLayerGraphs = buildLayerGraphs(g, _lodash2.default.range(1, maxRank + 1), 'inEdges');
var upLayerGraphs = buildLayerGraphs(g, _lodash2.default.range(maxRank - 1, -1, -1), 'outEdges');

var layering = (0, _initOrder2.default)(g);
assignOrder(g, layering);

var bestCC = Number.POSITIVE_INFINITY;
var best = void 0;

for (var i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
  sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);

  layering = _util2.default.buildLayerMatrix(g);
  var cc = (0, _crossCount2.default)(g, layering);
  if (cc < bestCC) {
    lastBest = 0;
    best = _lodash2.default.cloneDeep(layering);
    bestCC = cc;
  }
}

assignOrder(g, best);

}

function buildLayerGraphs(g, ranks, relationship) {

return _lodash2.default.map(ranks, function (rank) {
  return (0, _buildLayerGraph2.default)(g, rank, relationship);
});

}

function sweepLayerGraphs(layerGraphs, biasRight) {

var cg = new _graphlib.Graph();
_lodash2.default.each(layerGraphs, function (lg) {
  var root = lg.graph().root;
  var sorted = (0, _sortSubgraph2.default)(lg, root, cg, biasRight);
  _lodash2.default.each(sorted.vs, function (v, i) {
    lg.node(v).order = i;
  });
  (0, _addSubgraphConstraints2.default)(lg, cg, sorted.vs);
});

}

function assignOrder(g, layering) {

_lodash2.default.each(layering, function (layer) {
  _lodash2.default.each(layer, function (v, i) {
    g.node(v).order = i;
  });
});

}

exports.default = order;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* Assigns an initial order value for each node by performing a DFS search
* starting from nodes in the first rank. Nodes are assigned an order in their
* rank as they are first visited.
*
* This approach comes from Gansner, et al., "A Technique for Drawing Directed
* Graphs."
*
* Returns a layering matrix with an array per layer and each layer sorted by
* the order of its nodes.
*/

function initOrder(g) {

var visited = {};
var simpleNodes = _lodash2.default.filter(g.nodes(), function (v) {
  return !g.children(v).length;
});
var maxRank = _lodash2.default.max(_lodash2.default.map(simpleNodes, function (v) {
  return g.node(v).rank;
}));
var layers = _lodash2.default.map(_lodash2.default.range(maxRank + 1), function () {
  return [];
});

function dfs(v) {
  if (_lodash2.default.has(visited, v)) return;
  visited[v] = true;
  var node = g.node(v);
  layers[node.rank].push(v);
  _lodash2.default.each(g.successors(v), dfs);
}

var orderedVs = _lodash2.default.sortBy(simpleNodes, function (v) {
  return g.node(v).rank;
});
_lodash2.default.each(orderedVs, dfs);

return layers;

}

exports.default = initOrder;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* A function that takes a layering (an array of layers, each with an array of
* ordererd nodes) and a graph and returns a weighted crossing count.
*
* Pre-conditions:
*
*    1. Input graph must be simple (not a multigraph), directed, and include
*       only simple edges.
*    2. Edges in the input graph must have assigned weights.
*
* Post-conditions:
*
*    1. The graph and layering matrix are left unchanged.
*
* This algorithm is derived from Barth, et al., "Bilayer Cross Counting."
*/

function crossCount(g, layering) {

var cc = 0;
for (var i = 1; i < layering.length; ++i) {
  cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);
}
return cc;

}

function twoLayerCrossCount(g, northLayer, southLayer) {

// Sort all of the edges between the north and south layers by their position
// in the north layer and then the south. Map these edges to the position of
// their head in the south layer.
var southPos = _lodash2.default.zipObject(southLayer, _lodash2.default.map(southLayer, function (v, i) {
  return i;
}));
var southEntries = _lodash2.default.flatten(_lodash2.default.map(northLayer, function (v) {
  return _lodash2.default.chain(g.outEdges(v)).map(function (e) {
    return { pos: southPos[e.w], weight: g.edge(e).weight };
  }).sortBy('pos').value();
}), true);

// Build the accumulator tree
var firstIndex = 1;
while (firstIndex < southLayer.length) {
  firstIndex <<= 1;
}
var treeSize = 2 * firstIndex - 1;
firstIndex -= 1;
var tree = _lodash2.default.map(new Array(treeSize), function () {
  return 0;
});

// Calculate the weighted crossings
var cc = 0;
_lodash2.default.each(southEntries.forEach(function (entry) {
  var index = entry.pos + firstIndex;
  tree[index] += entry.weight;
  var weightSum = 0;
  while (index > 0) {
    if (index % 2) {
      weightSum += tree[index + 1];
    }
    index = index - 1 >> 1;
    tree[index] += entry.weight;
  }
  cc += entry.weight * weightSum;
}));

return cc;

}

exports.default = crossCount;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _barycenter = webpack_require(21);

var _barycenter2 = _interopRequireDefault(_barycenter);

var _resolveConflicts = webpack_require(22);

var _resolveConflicts2 = _interopRequireDefault(_resolveConflicts);

var _sort = webpack_require(23);

var _sort2 = _interopRequireDefault(_sort);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function sortSubgraph(g, v, cg, biasRight) {

var movable = g.children(v);
var node = g.node(v);
var bl = node ? node.borderLeft : undefined;
var br = node ? node.borderRight : undefined;
var subgraphs = {};

if (bl) {
  movable = _lodash2.default.filter(movable, function (w) {
    return w !== bl && w !== br;
  });
}

var barycenters = (0, _barycenter2.default)(g, movable);
_lodash2.default.each(barycenters, function (entry) {
  if (g.children(entry.v).length) {
    var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
    subgraphs[entry.v] = subgraphResult;
    if (_lodash2.default.has(subgraphResult, 'barycenter')) {
      mergeBarycenters(entry, subgraphResult);
    }
  }
});

var entries = (0, _resolveConflicts2.default)(barycenters, cg);
expandSubgraphs(entries, subgraphs);

var result = (0, _sort2.default)(entries, biasRight);

if (bl) {
  result.vs = _lodash2.default.flatten([bl, result.vs, br], true);
  if (g.predecessors(bl).length) {
    var blPred = g.node(g.predecessors(bl)[0]);
    var brPred = g.node(g.predecessors(br)[0]);
    if (!_lodash2.default.has(result, 'barycenter')) {
      result.barycenter = 0;
      result.weight = 0;
    }
    result.barycenter = (result.barycenter * result.weight + blPred.order + brPred.order) / (result.weight + 2);
    result.weight += 2;
  }
}

return result;

}

function expandSubgraphs(entries, subgraphs) {

_lodash2.default.each(entries, function (entry) {
  entry.vs = _lodash2.default.flatten(entry.vs.map(function (v) {
    if (subgraphs[v]) {
      return subgraphs[v].vs;
    }
    return v;
  }), true);
});

}

function mergeBarycenters(target, other) {

if (!_lodash2.default.isUndefined(target.barycenter)) {
  target.barycenter = (target.barycenter * target.weight + other.barycenter * other.weight) / (target.weight + other.weight);
  target.weight += other.weight;
} else {
  target.barycenter = other.barycenter;
  target.weight = other.weight;
}

}

exports.default = sortSubgraph;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function barycenter(g, movable) {

return _lodash2.default.map(movable, function (v) {
  var inV = g.inEdges(v);
  if (!inV.length) {
    return { v: v };
  } else {
    var result = _lodash2.default.reduce(inV, function (acc, e) {
      var edge = g.edge(e);
      var nodeU = g.node(e.v);
      return {
        sum: acc.sum + edge.weight * nodeU.order,
        weight: acc.weight + edge.weight
      };
    }, { sum: 0, weight: 0 });

    return {
      v: v,
      barycenter: result.sum / result.weight,
      weight: result.weight
    };
  }
});

}

exports.default = barycenter;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* Given a list of entries of the form {v, barycenter, weight} and a
* constraint graph this function will resolve any conflicts between the
* constraint graph and the barycenters for the entries. If the barycenters for
* an entry would violate a constraint in the constraint graph then we coalesce
* the nodes in the conflict into a new node that respects the contraint and
* aggregates barycenter and weight information.
*
* This implementation is based on the description in Forster, "A Fast and
* Simple Hueristic for Constrained Two-Level Crossing Reduction," thought it
* differs in some specific details.
*
* Pre-conditions:
*
*    1. Each entry has the form {v, barycenter, weight}, or if the node has
*       no barycenter, then {v}.
*
* Returns:
*
*    A new list of entries of the form {vs, i, barycenter, weight}. The list
*    `vs` may either be a singleton or it may be an aggregation of nodes
*    ordered such that they do not violate constraints from the constraint
*    graph. The property `i` is the lowest original index of any of the
*    elements in `vs`.
*/

function resolveConflicts(entries, cg) {

var mappedEntries = {};
_lodash2.default.each(entries, function (entry, i) {
  var tmp = mappedEntries[entry.v] = {
    indegree: 0,
    'in': [],
    out: [],
    vs: [entry.v],
    i: i
  };
  if (!_lodash2.default.isUndefined(entry.barycenter)) {
    tmp.barycenter = entry.barycenter;
    tmp.weight = entry.weight;
  }
});

_lodash2.default.each(cg.edges(), function (e) {
  var entryV = mappedEntries[e.v];
  var entryW = mappedEntries[e.w];
  if (!_lodash2.default.isUndefined(entryV) && !_lodash2.default.isUndefined(entryW)) {
    entryW.indegree++;
    entryV.out.push(mappedEntries[e.w]);
  }
});

var sourceSet = _lodash2.default.filter(mappedEntries, function (entry) {
  return !entry.indegree;
});

return doResolveConflicts(sourceSet);

}

function doResolveConflicts(sourceSet) {

var entries = [];

function handleIn(vEntry) {
  return function (uEntry) {
    if (uEntry.merged) {
      return;
    }
    if (_lodash2.default.isUndefined(uEntry.barycenter) || _lodash2.default.isUndefined(vEntry.barycenter) || uEntry.barycenter >= vEntry.barycenter) {
      mergeEntries(vEntry, uEntry);
    }
  };
}

function handleOut(vEntry) {
  return function (wEntry) {
    wEntry['in'].push(vEntry);
    if (--wEntry.indegree === 0) {
      sourceSet.push(wEntry);
    }
  };
}

while (sourceSet.length) {
  var entry = sourceSet.pop();
  entries.push(entry);
  _lodash2.default.each(entry['in'].reverse(), handleIn(entry));
  _lodash2.default.each(entry.out, handleOut(entry));
}

return _lodash2.default.chain(entries).filter(function (entry) {
  return !entry.merged;
}).map(function (entry) {
  return _lodash2.default.pick(entry, ['vs', 'i', 'barycenter', 'weight']);
}).value();

}

function mergeEntries(target, source) {

var sum = 0;
var weight = 0;

if (target.weight) {
  sum += target.barycenter * target.weight;
  weight += target.weight;
}

if (source.weight) {
  sum += source.barycenter * source.weight;
  weight += source.weight;
}

target.vs = source.vs.concat(target.vs);
target.barycenter = sum / weight;
target.weight = weight;
target.i = Math.min(source.i, target.i);
source.merged = true;

}

exports.default = resolveConflicts;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _util = webpack_require(1);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function sort(entries, biasRight) {

var parts = _util2.default.partition(entries, function (entry) {
  return _lodash2.default.has(entry, 'barycenter');
});
var sortable = parts.lhs;
var unsortable = _lodash2.default.sortBy(parts.rhs, function (entry) {
  return -entry.i;
});
var vs = [];
var sum = 0;
var weight = 0;
var vsIndex = 0;

sortable.sort(compareWithBias(!!biasRight));

vsIndex = consumeUnsortable(vs, unsortable, vsIndex);

_lodash2.default.each(sortable, function (entry) {
  vsIndex += entry.vs.length;
  vs.push(entry.vs);
  sum += entry.barycenter * entry.weight;
  weight += entry.weight;
  vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
});

var result = { vs: _lodash2.default.flatten(vs, true) };
if (weight) {
  result.barycenter = sum / weight;
  result.weight = weight;
}
return result;

}

function consumeUnsortable(vs, unsortable, index) {

var last = void 0;
while (unsortable.length && (last = _lodash2.default.last(unsortable)).i <= index) {
  unsortable.pop();
  vs.push(last.vs);
  index++;
}
return index;

}

function compareWithBias(bias) {

return function (entryV, entryW) {
  if (entryV.barycenter < entryW.barycenter) {
    return -1;
  } else if (entryV.barycenter > entryW.barycenter) {
    return 1;
  }

  return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;
};

}

exports.default = sort;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _graphlib = webpack_require(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* Constructs a graph that can be used to sort a layer of nodes. The graph will
* contain all base and subgraph nodes from the request layer in their original
* hierarchy and any edges that are incident on these nodes and are of the type
* requested by the "relationship" parameter.
*
* Nodes from the requested rank that do not have parents are assigned a root
* node in the output graph, which is set in the root graph attribute. This
* makes it easy to walk the hierarchy of movable nodes during ordering.
*
* Pre-conditions:
*
*    1. Input graph is a DAG
*    2. Base nodes in the input graph have a rank attribute
*    3. Subgraph nodes in the input graph has minRank and maxRank attributes
*    4. Edges have an assigned weight
*
* Post-conditions:
*
*    1. Output graph has all nodes in the movable rank with preserved
*       hierarchy.
*    2. Root nodes in the movable layer are made children of the node
*       indicated by the root attribute of the graph.
*    3. Non-movable nodes incident on movable nodes, selected by the
*       relationship parameter, are included in the graph (without hierarchy).
*    4. Edges incident on movable nodes, selected by the relationship
*       parameter, are added to the output graph.
*    5. The weights for copied edges are aggregated as need, since the output
*       graph is not a multi-graph.
*/

function buildLayerGraph(g, rank, relationship) {

var root = createRootNode(g);
var result = new _graphlib.Graph({ compound: true }).setGraph({ root: root }).setDefaultNodeLabel(function (v) {
  return g.node(v);
});

_lodash2.default.each(g.nodes(), function (v) {
  var node = g.node(v);
  var parent = g.parent(v);

  if (node.rank === rank || node.minRank <= rank && rank <= node.maxRank) {
    result.setNode(v);
    result.setParent(v, parent || root);

    // This assumes we have only short edges!
    _lodash2.default.each(g[relationship](v), function (e) {
      var u = e.v === v ? e.w : e.v;
      var edge = result.edge(u, v);
      var weight = !_lodash2.default.isUndefined(edge) ? edge.weight : 0;
      result.setEdge(u, v, { weight: g.edge(e).weight + weight });
    });

    if (_lodash2.default.has(node, 'minRank')) {
      result.setNode(v, {
        borderLeft: node.borderLeft[rank],
        borderRight: node.borderRight[rank]
      });
    }
  }
});

return result;

}

function createRootNode(g) {

var v = void 0;
while (g.hasNode(v = _lodash2.default.uniqueId('_root'))) {}
return v;

}

exports.default = buildLayerGraph;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function addSubgraphConstraints(g, cg, vs) {

var prev = {};
var rootPrev = void 0;

_lodash2.default.each(vs, function (v) {
  var child = g.parent(v);
  var parent = void 0;
  var prevChild = void 0;
  while (child) {
    parent = g.parent(child);
    if (parent) {
      prevChild = prev[parent];
      prev[parent] = child;
    } else {
      prevChild = rootPrev;
      rootPrev = child;
    }
    if (prevChild && prevChild !== child) {
      cg.setEdge(prevChild, child);
      return;
    }
    child = parent;
  }
});

/*
function dfs(v) {
  const children = v ? g.children(v) : g.children();
  if (children.length) {
    const min = Number.POSITIVE_INFINITY,
        subgraphs = [];
    _.each(children, function(child) {
      const childMin = dfs(child);
      if (g.children(child).length) {
        subgraphs.push({ v: child, order: childMin });
      }
      min = Math.min(min, childMin);
    });
    _.reduce(_.sortBy(subgraphs, "order"), function(prev, curr) {
      cg.setEdge(prev.v, curr.v);
      return curr;
    });
    return min;
  }
  return g.node(v).order;
}
dfs(undefined);
*/

}

exports.default = addSubgraphConstraints;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _util = webpack_require(1);

var _util2 = _interopRequireDefault(_util);

var _bk = webpack_require(27);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function position(g) {

g = _util2.default.asNonCompoundGraph(g);

positionY(g);
_lodash2.default.each((0, _bk.positionX)(g), function (x, v) {
  g.node(v).x = x;
});

}

function positionY(g) {

var layering = _util2.default.buildLayerMatrix(g);
var rankSep = g.graph().ranksep;
var prevY = 0;
_lodash2.default.each(layering, function (layer) {
  var maxHeight = _lodash2.default.max(_lodash2.default.map(layer, function (v) {
    return g.node(v).height;
  }));
  _lodash2.default.each(layer, function (v) {
    g.node(v).y = prevY + maxHeight / 2;
  });
  prevY += maxHeight + rankSep;
});

}

exports.default = position;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.positionX = positionX;

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _graphlib = webpack_require(2);

var _util = webpack_require(1);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* This module provides coordinate assignment based on Brandes and Köpf, "Fast
* and Simple Horizontal Coordinate Assignment."
*/

/*

* Marks all edges in the graph with a type-1 conflict with the "type1Conflict"
* property. A type-1 conflict is one where a non-inner segment crosses an
* inner segment. An inner segment is an edge with both incident nodes marked
* with the "dummy" property.
*
* This algorithm scans layer by layer, starting with the second, for type-1
* conflicts between the current layer and the previous layer. For each layer
* it scans the nodes from left to right until it reaches one that is incident
* on an inner segment. It then scans predecessors to determine if they have
* edges that cross that inner segment. At the end a final scan is done for all
* nodes on the current rank to see if they cross the last visited inner
* segment.
*
* This algorithm (safely) assumes that a dummy node will only be incident on a
* single node in the layers being scanned.
*/

function findType1Conflicts(g, layering) {

var conflicts = {};

function visitLayer(prevLayer, layer) {
  // last visited node in the previous layer that is incident on an inner
  // segment.
  var k0 = 0;
  // Tracks the last node in this layer scanned for crossings with a type-1
  // segment.
  var scanPos = 0;
  var prevLayerLength = prevLayer.length;
  var lastNode = _lodash2.default.last(layer);

  _lodash2.default.each(layer, function (v, i) {
    var w = findOtherInnerSegmentNode(g, v);
    var k1 = w ? g.node(w).order : prevLayerLength;

    if (w || v === lastNode) {
      _lodash2.default.each(layer.slice(scanPos, i + 1), function (scanNode) {
        _lodash2.default.each(g.predecessors(scanNode), function (u) {
          var uLabel = g.node(u);
          var uPos = uLabel.order;
          if ((uPos < k0 || k1 < uPos) && !(uLabel.dummy && g.node(scanNode).dummy)) {
            addConflict(conflicts, u, scanNode);
          }
        });
      });
      scanPos = i + 1;
      k0 = k1;
    }
  });

  return layer;
}

_lodash2.default.reduce(layering, visitLayer);
return conflicts;

}

function findType2Conflicts(g, layering) {

var conflicts = {};

function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
  var v = void 0;
  _lodash2.default.each(_lodash2.default.range(southPos, southEnd), function (i) {
    v = south[i];
    if (g.node(v).dummy) {
      _lodash2.default.each(g.predecessors(v), function (u) {
        var uNode = g.node(u);
        if (uNode.dummy && (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
          addConflict(conflicts, u, v);
        }
      });
    }
  });
}

function visitLayer(north, south) {
  var prevNorthPos = -1;
  var nextNorthPos = void 0;
  var southPos = 0;

  _lodash2.default.each(south, function (v, southLookahead) {
    if (g.node(v).dummy === 'border') {
      var predecessors = g.predecessors(v);
      if (predecessors.length) {
        nextNorthPos = g.node(predecessors[0]).order;
        scan(south, southPos, southLookahead, prevNorthPos, nextNorthPos);
        southPos = southLookahead;
        prevNorthPos = nextNorthPos;
      }
    }
    scan(south, southPos, south.length, nextNorthPos, north.length);
  });

  return south;
}

_lodash2.default.reduce(layering, visitLayer);
return conflicts;

}

function findOtherInnerSegmentNode(g, v) {

if (g.node(v).dummy) {
  return _lodash2.default.find(g.predecessors(v), function (u) {
    return g.node(u).dummy;
  });
}

}

function addConflict(conflicts, v, w) {

if (v > w) {
  var tmp = v;
  v = w;
  w = tmp;
}

var conflictsV = conflicts[v];
if (!conflictsV) {
  conflicts[v] = conflictsV = {};
}
conflictsV[w] = true;

}

function hasConflict(conflicts, v, w) {

if (v > w) {
  var tmp = v;
  v = w;
  w = tmp;
}
return _lodash2.default.has(conflicts[v], w);

}

/*

* Try to align nodes into vertical "blocks" where possible. This algorithm
* attempts to align a node with one of its median neighbors. If the edge
* connecting a neighbor is a type-1 conflict then we ignore that possibility.
* If a previous node has already formed a block with a node after the node
* we're trying to form a block with, we also ignore that possibility - our
* blocks would be split in that scenario.
*/

function verticalAlignment(g, layering, conflicts, neighborFn) {

var root = {};
var align = {};
var pos = {};

// We cache the position here based on the layering because the graph and
// layering may be out of sync. The layering matrix is manipulated to
// generate different extreme alignments.
_lodash2.default.each(layering, function (layer) {
  _lodash2.default.each(layer, function (v, order) {
    root[v] = v;
    align[v] = v;
    pos[v] = order;
  });
});

_lodash2.default.each(layering, function (layer) {
  var prevIdx = -1;
  _lodash2.default.each(layer, function (v) {
    var ws = neighborFn(v);
    if (ws.length) {
      ws = _lodash2.default.sortBy(ws, function (w) {
        return pos[w];
      });
      var mp = (ws.length - 1) / 2;
      for (var i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
        var w = ws[i];
        if (align[v] === v && prevIdx < pos[w] && !hasConflict(conflicts, v, w)) {
          align[w] = v;
          align[v] = root[v] = root[w];
          prevIdx = pos[w];
        }
      }
    }
  });
});

return { root: root, align: align };

}

function horizontalCompaction(g, layering, root, align, reverseSep) {

// This portion of the algorithm differs from BK due to a number of problems.
// Instead of their algorithm we construct a new block graph and do two
// sweeps. The first sweep places blocks with the smallest possible
// coordinates. The second sweep removes unused space by moving blocks to the
// greatest coordinates without violating separation.
var xs = {};
var blockG = buildBlockGraph(g, layering, root, reverseSep);

// First pass, assign smallest coordinates via DFS
var visited = {};
function pass1(v) {
  if (!_lodash2.default.has(visited, v)) {
    visited[v] = true;
    xs[v] = _lodash2.default.reduce(blockG.inEdges(v), function (max, e) {
      pass1(e.v);
      return Math.max(max, xs[e.v] + blockG.edge(e));
    }, 0);
  }
}
_lodash2.default.each(blockG.nodes(), pass1);

var borderType = reverseSep ? 'borderLeft' : 'borderRight';
function pass2(v) {
  if (visited[v] !== 2) {
    visited[v]++;
    var node = g.node(v);
    var min = _lodash2.default.reduce(blockG.outEdges(v), function (min, e) {
      pass2(e.w);
      return Math.min(min, xs[e.w] - blockG.edge(e));
    }, Number.POSITIVE_INFINITY);
    if (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) {
      xs[v] = Math.max(xs[v], min);
    }
  }
}
_lodash2.default.each(blockG.nodes(), pass2);

// Assign x coordinates to all nodes
_lodash2.default.each(align, function (v) {
  xs[v] = xs[root[v]];
});

return xs;

}

function buildBlockGraph(g, layering, root, reverseSep) {

var blockGraph = new _graphlib.Graph();
var graphLabel = g.graph();
var sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);

_lodash2.default.each(layering, function (layer) {
  var u = void 0;
  _lodash2.default.each(layer, function (v) {
    var vRoot = root[v];
    blockGraph.setNode(vRoot);
    if (u) {
      var uRoot = root[u];
      var prevMax = blockGraph.edge(uRoot, vRoot);
      blockGraph.setEdge(uRoot, vRoot, Math.max(sepFn(g, v, u), prevMax || 0));
    }
    u = v;
  });
});

return blockGraph;

}

/*

* Returns the alignment that has the smallest width of the given alignments.
*/

function findSmallestWidthAlignment(g, xss) {

return _lodash2.default.minBy(_lodash2.default.values(xss), function (xs) {
  var min = (_lodash2.default.minBy(_lodash2.default.toPairs(xs), function (pair) {
    return pair[1] - width(g, pair[0]) / 2;
  }) || ['k', 0])[1];
  var max = (_lodash2.default.maxBy(_lodash2.default.toPairs(xs), function (pair) {
    return pair[1] + width(g, pair[0]) / 2;
  }) || ['k', 0])[1];
  return max - min;
});

}

/*

* Align the coordinates of each of the layout alignments such that
* left-biased alignments have their minimum coordinate at the same point as
* the minimum coordinate of the smallest width alignment and right-biased
* alignments have their maximum coordinate at the same point as the maximum
* coordinate of the smallest width alignment.
*/

function alignCoordinates(xss, alignTo) {

var alignToMin = _lodash2.default.min(_lodash2.default.values(alignTo));
var alignToMax = _lodash2.default.max(_lodash2.default.values(alignTo));

_lodash2.default.each(['u', 'd'], function (vert) {
  _lodash2.default.each(['l', 'r'], function (horiz) {
    var alignment = vert + horiz;
    var xs = xss[alignment];
    if (xs === alignTo) {
      return;
    }
    var delta = horiz === 'l' ? alignToMin - _lodash2.default.min(_lodash2.default.values(xs)) : alignToMax - _lodash2.default.max(_lodash2.default.values(xs));
    if (delta) {
      xss[alignment] = _lodash2.default.mapValues(xs, function (x) {
        return x + delta;
      });
    }
  });
});

}

function balance(xss, align) {

return _lodash2.default.mapValues(xss.ul, function (ignore, v) {
  if (align) {
    return xss[align.toLowerCase()][v];
  } else {
    var xs = _lodash2.default.sortBy(_lodash2.default.map(xss, v));
    return (xs[1] + xs[2]) / 2;
  }
});

}

function positionX(g) {

var layering = _util2.default.buildLayerMatrix(g);
var conflicts = _lodash2.default.merge(findType1Conflicts(g, layering), findType2Conflicts(g, layering));

var xss = {};
var adjustedLayering = void 0;
_lodash2.default.each(['u', 'd'], function (vert) {
  adjustedLayering = vert === 'u' ? layering : _lodash2.default.values(layering).reverse();
  _lodash2.default.each(['l', 'r'], function (horiz) {
    if (horiz === 'r') {
      adjustedLayering = _lodash2.default.map(adjustedLayering, function (inner) {
        return _lodash2.default.values(inner).reverse();
      });
    }

    var neighborFn = _lodash2.default.bind(vert === 'u' ? g.predecessors : g.successors, g);
    var align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
    var xs = horizontalCompaction(g, adjustedLayering, align.root, align.align, horiz === 'r');
    if (horiz === 'r') {
      xs = _lodash2.default.mapValues(xs, function (x) {
        return -x;
      });
    }
    xss[vert + horiz] = xs;
  });
});

var smallestWidth = findSmallestWidthAlignment(g, xss);
alignCoordinates(xss, smallestWidth);
return balance(xss, g.graph().align);

}

function sep(nodeSep, edgeSep, reverseSep) {

return function (g, v, w) {
  var vLabel = g.node(v);
  var wLabel = g.node(w);
  var sum = 0;
  var delta = void 0;

  sum += vLabel.width / 2;
  if (_lodash2.default.has(vLabel, 'labelpos')) {
    switch (vLabel.labelpos.toLowerCase()) {
      case 'l':
        delta = -vLabel.width / 2;break;
      case 'r':
        delta = vLabel.width / 2;break;
    }
  }
  if (delta) {
    sum += reverseSep ? delta : -delta;
  }
  delta = 0;

  sum += (vLabel.dummy ? edgeSep : nodeSep) / 2;
  sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;

  sum += wLabel.width / 2;
  if (_lodash2.default.has(wLabel, 'labelpos')) {
    switch (wLabel.labelpos.toLowerCase()) {
      case 'l':
        delta = wLabel.width / 2;break;
      case 'r':
        delta = -wLabel.width / 2;break;
    }
  }
  if (delta) {
    sum += reverseSep ? delta : -delta;
  }
  delta = 0;

  return sum;
};

}

function width(g, v) {

return g.node(v).width;

}

exports.default = {

positionX: positionX,
findType1Conflicts: findType1Conflicts,
findType2Conflicts: findType2Conflicts,
addConflict: addConflict,
hasConflict: hasConflict,
verticalAlignment: verticalAlignment,
horizontalCompaction: horizontalCompaction,
alignCoordinates: alignCoordinates,
findSmallestWidthAlignment: findSmallestWidthAlignment,
balance: balance

};

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(0);

var _lodash2 = _interopRequireDefault(_lodash);

var _graphlib = webpack_require(2);

var _util = webpack_require(1);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/* istanbul ignore next */ function debugOrdering(g) {

var layerMatrix = _util2.default.buildLayerMatrix(g);

var h = new _graphlib.Graph({ compound: true, multigraph: true }).setGraph({});

_lodash2.default.each(g.nodes(), function (v) {
  h.setNode(v, { label: v });
  h.setParent(v, 'layer' + g.node(v).rank);
});

_lodash2.default.each(g.edges(), function (e) {
  h.setEdge(e.v, e.w, {}, e.name);
});

_lodash2.default.each(layerMatrix, function (layer, i) {
  var layerV = 'layer' + i;
  h.setNode(layerV, { rank: 'same' });
  _lodash2.default.reduce(layer, function (u, v) {
    h.setEdge(u, v, { style: 'invis' });
    return v;
  });
});

return h;

}

exports.default = {

debugOrdering: debugOrdering

};

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

module.exports = {“name”:“dagre-layout”,“version”:“0.7.9”,“description”:“Graph layout for JavaScript”,“author”:“Tyler Long <tyler4long@gmail.com>”,“main”:“dist/dagre-layout.js”,“keywords”:,“scripts”:{“lint”:“standard”,“jest”:“jest –coverage”,“karma”:“node -r babel-register node_modules/.bin/karma start”,“test”:“yarn lint && yarn jest && yarn karma –single-run”,“bench”:“node -r babel-register src/bench.js”,“build”:“node -r babel-register node_modules/.bin/webpack –progress –colors”,“build:watch”:“yarn build –watch”,“upgrade”:“yarn-upgrade-all”},“dependencies”:{“graphlib”:“^2.1.1”,“lodash”:“^4.17.4”},“devDependencies”:{“babel-core”:“^6.26.0”,“babel-loader”:“^7.1.2”,“babel-preset-env”:“^1.6.0”,“babel-preset-es2015”:“^6.24.1”,“benchmark”:“^2.1.4”,“chai”:“^4.1.2”,“coveralls”:“^2.13.1”,“jest”:“^21.0.1”,“karma”:“^1.7.1”,“karma-chrome-launcher”:“^2.2.0”,“karma-firefox-launcher”:“^1.0.1”,“karma-mocha”:“^1.3.0”,“karma-safari-launcher”:“^1.0.0”,“mocha”:“^3.5.0”,“sprintf”:“^0.1.5”,“standard”:“^10.0.3”,“webpack”:“^3.5.6”,“webpack-node-externals”:“^1.6.0”,“yarn-upgrade-all”:“^0.1.8”},“repository”:{“type”:“git”,“url”:“github.com/tylingsoft/dagre-layout.git”},“license”:“MIT”,“files”:[“dist/”,“lib/”,“index.js”],“standard”:{“ignore”:[“dist/*/.js”,“coverage/*/.js”]},“jest”:{“testRegex”:“test/.+?-test\.js”,“testPathIgnorePatterns”:[“test/bundle-test\.js”]}}

/***/ }) /******/ ])[“default”]; });

/***/ }), /* 31 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

var _ = webpack_require(4);

module.exports = Graph;

var DEFAULT_EDGE_NAME = “x00”,

GRAPH_NODE = "\x00",
EDGE_KEY_DELIM = "\x01";

// Implementation notes: // // * Node id query functions should return string ids for the nodes // * Edge id query functions should return an “edgeObj”, edge object, that is // composed of enough information to uniquely identify an edge: {v, w, name}. // * Internally we use an “edgeId”, a stringified form of the edgeObj, to // reference edges. This is because we need a performant way to look these // edges up and, object properties, which have string keys, are the closest // we're going to get to a performant hashtable in JavaScript.

function Graph(opts) {

this._isDirected = _.has(opts, "directed") ? opts.directed : true;
this._isMultigraph = _.has(opts, "multigraph") ? opts.multigraph : false;
this._isCompound = _.has(opts, "compound") ? opts.compound : false;

// Label for the graph itself
this._label = undefined;

// Defaults to be set when creating a new node
this._defaultNodeLabelFn = _.constant(undefined);

// Defaults to be set when creating a new edge
this._defaultEdgeLabelFn = _.constant(undefined);

// v -> label
this._nodes = {};

if (this._isCompound) {
  // v -> parent
  this._parent = {};

  // v -> children
  this._children = {};
  this._children[GRAPH_NODE] = {};
}

// v -> edgeObj
this._in = {};

// u -> v -> Number
this._preds = {};

// v -> edgeObj
this._out = {};

// v -> w -> Number
this._sucs = {};

// e -> edgeObj
this._edgeObjs = {};

// e -> label
this._edgeLabels = {};

}

/* Number of nodes in the graph. Should only be changed by the implementation. */ Graph.prototype._nodeCount = 0;

/* Number of edges in the graph. Should only be changed by the implementation. */ Graph.prototype._edgeCount = 0;

/* === Graph functions ========= */

Graph.prototype.isDirected = function() {

return this._isDirected;

};

Graph.prototype.isMultigraph = function() {

return this._isMultigraph;

};

Graph.prototype.isCompound = function() {

return this._isCompound;

};

Graph.prototype.setGraph = function(label) {

this._label = label;
return this;

};

Graph.prototype.graph = function() {

return this._label;

};

/* === Node functions ========== */

Graph.prototype.setDefaultNodeLabel = function(newDefault) {

if (!_.isFunction(newDefault)) {
  newDefault = _.constant(newDefault);
}
this._defaultNodeLabelFn = newDefault;
return this;

};

Graph.prototype.nodeCount = function() {

return this._nodeCount;

};

Graph.prototype.nodes = function() {

return _.keys(this._nodes);

};

Graph.prototype.sources = function() {

return _.filter(this.nodes(), _.bind(function(v) {
  return _.isEmpty(this._in[v]);
}, this));

};

Graph.prototype.sinks = function() {

return _.filter(this.nodes(), _.bind(function(v) {
  return _.isEmpty(this._out[v]);
}, this));

};

Graph.prototype.setNodes = function(vs, value) {

var args = arguments;
_.each(vs, _.bind(function(v) {
  if (args.length > 1) {
    this.setNode(v, value);
  } else {
    this.setNode(v);
  }
}, this));
return this;

};

Graph.prototype.setNode = function(v, value) {

if (_.has(this._nodes, v)) {
  if (arguments.length > 1) {
    this._nodes[v] = value;
  }
  return this;
}

this._nodes[v] = arguments.length > 1 ? value : this._defaultNodeLabelFn(v);
if (this._isCompound) {
  this._parent[v] = GRAPH_NODE;
  this._children[v] = {};
  this._children[GRAPH_NODE][v] = true;
}
this._in[v] = {};
this._preds[v] = {};
this._out[v] = {};
this._sucs[v] = {};
++this._nodeCount;
return this;

};

Graph.prototype.node = function(v) {

return this._nodes[v];

};

Graph.prototype.hasNode = function(v) {

return _.has(this._nodes, v);

};

Graph.prototype.removeNode = function(v) {

var self = this;
if (_.has(this._nodes, v)) {
  var removeEdge = function(e) { self.removeEdge(self._edgeObjs[e]); };
  delete this._nodes[v];
  if (this._isCompound) {
    this._removeFromParentsChildList(v);
    delete this._parent[v];
    _.each(this.children(v), _.bind(function(child) {
      this.setParent(child);
    }, this));
    delete this._children[v];
  }
  _.each(_.keys(this._in[v]), removeEdge);
  delete this._in[v];
  delete this._preds[v];
  _.each(_.keys(this._out[v]), removeEdge);
  delete this._out[v];
  delete this._sucs[v];
  --this._nodeCount;
}
return this;

};

Graph.prototype.setParent = function(v, parent) {

if (!this._isCompound) {
  throw new Error("Cannot set parent in a non-compound graph");
}

if (_.isUndefined(parent)) {
  parent = GRAPH_NODE;
} else {
  // Coerce parent to string
  parent += "";
  for (var ancestor = parent;
       !_.isUndefined(ancestor);
       ancestor = this.parent(ancestor)) {
    if (ancestor === v) {
      throw new Error("Setting " + parent+ " as parent of " + v +
                      " would create create a cycle");
    }
  }

  this.setNode(parent);
}

this.setNode(v);
this._removeFromParentsChildList(v);
this._parent[v] = parent;
this._children[parent][v] = true;
return this;

};

Graph.prototype._removeFromParentsChildList = function(v) {

delete this._children[this._parent[v]][v];

};

Graph.prototype.parent = function(v) {

if (this._isCompound) {
  var parent = this._parent[v];
  if (parent !== GRAPH_NODE) {
    return parent;
  }
}

};

Graph.prototype.children = function(v) {

if (_.isUndefined(v)) {
  v = GRAPH_NODE;
}

if (this._isCompound) {
  var children = this._children[v];
  if (children) {
    return _.keys(children);
  }
} else if (v === GRAPH_NODE) {
  return this.nodes();
} else if (this.hasNode(v)) {
  return [];
}

};

Graph.prototype.predecessors = function(v) {

var predsV = this._preds[v];
if (predsV) {
  return _.keys(predsV);
}

};

Graph.prototype.successors = function(v) {

var sucsV = this._sucs[v];
if (sucsV) {
  return _.keys(sucsV);
}

};

Graph.prototype.neighbors = function(v) {

var preds = this.predecessors(v);
if (preds) {
  return _.union(preds, this.successors(v));
}

};

Graph.prototype.filterNodes = function(filter) {

var copy = new this.constructor({
  directed: this._isDirected,
  multigraph: this._isMultigraph,
  compound: this._isCompound
});

copy.setGraph(this.graph());

_.each(this._nodes, _.bind(function(value, v) {
  if (filter(v)) {
    copy.setNode(v, value);
  }
}, this));

_.each(this._edgeObjs, _.bind(function(e) {
  if (copy.hasNode(e.v) && copy.hasNode(e.w)) {
    copy.setEdge(e, this.edge(e));
  }
}, this));

var self = this;
var parents = {};
function findParent(v) {
  var parent = self.parent(v);
  if (parent === undefined || copy.hasNode(parent)) {
    parents[v] = parent;
    return parent;
  } else if (parent in parents) {
    return parents[parent];
  } else {
    return findParent(parent);
  }
}

if (this._isCompound) {
  _.each(copy.nodes(), function(v) {
    copy.setParent(v, findParent(v));
  });
}

return copy;

};

/* === Edge functions ========== */

Graph.prototype.setDefaultEdgeLabel = function(newDefault) {

if (!_.isFunction(newDefault)) {
  newDefault = _.constant(newDefault);
}
this._defaultEdgeLabelFn = newDefault;
return this;

};

Graph.prototype.edgeCount = function() {

return this._edgeCount;

};

Graph.prototype.edges = function() {

return _.values(this._edgeObjs);

};

Graph.prototype.setPath = function(vs, value) {

var self = this,
    args = arguments;
_.reduce(vs, function(v, w) {
  if (args.length > 1) {
    self.setEdge(v, w, value);
  } else {
    self.setEdge(v, w);
  }
  return w;
});
return this;

};

/*

* setEdge(v, w, [value, [name]])
* setEdge({ v, w, [name] }, [value])
*/

Graph.prototype.setEdge = function() {

var v, w, name, value,
    valueSpecified = false,
    arg0 = arguments[0];

if (typeof arg0 === "object" && arg0 !== null && "v" in arg0) {
  v = arg0.v;
  w = arg0.w;
  name = arg0.name;
  if (arguments.length === 2) {
    value = arguments[1];
    valueSpecified = true;
  }
} else {
  v = arg0;
  w = arguments[1];
  name = arguments[3];
  if (arguments.length > 2) {
    value = arguments[2];
    valueSpecified = true;
  }
}

v = "" + v;
w = "" + w;
if (!_.isUndefined(name)) {
  name = "" + name;
}

var e = edgeArgsToId(this._isDirected, v, w, name);
if (_.has(this._edgeLabels, e)) {
  if (valueSpecified) {
    this._edgeLabels[e] = value;
  }
  return this;
}

if (!_.isUndefined(name) && !this._isMultigraph) {
  throw new Error("Cannot set a named edge when isMultigraph = false");
}

// It didn't exist, so we need to create it.
// First ensure the nodes exist.
this.setNode(v);
this.setNode(w);

this._edgeLabels[e] = valueSpecified ? value : this._defaultEdgeLabelFn(v, w, name);

var edgeObj = edgeArgsToObj(this._isDirected, v, w, name);
// Ensure we add undirected edges in a consistent way.
v = edgeObj.v;
w = edgeObj.w;

Object.freeze(edgeObj);
this._edgeObjs[e] = edgeObj;
incrementOrInitEntry(this._preds[w], v);
incrementOrInitEntry(this._sucs[v], w);
this._in[w][e] = edgeObj;
this._out[v][e] = edgeObj;
this._edgeCount++;
return this;

};

Graph.prototype.edge = function(v, w, name) {

var e = (arguments.length === 1
          ? edgeObjToId(this._isDirected, arguments[0])
          : edgeArgsToId(this._isDirected, v, w, name));
return this._edgeLabels[e];

};

Graph.prototype.hasEdge = function(v, w, name) {

var e = (arguments.length === 1
          ? edgeObjToId(this._isDirected, arguments[0])
          : edgeArgsToId(this._isDirected, v, w, name));
return _.has(this._edgeLabels, e);

};

Graph.prototype.removeEdge = function(v, w, name) {

var e = (arguments.length === 1
          ? edgeObjToId(this._isDirected, arguments[0])
          : edgeArgsToId(this._isDirected, v, w, name)),
    edge = this._edgeObjs[e];
if (edge) {
  v = edge.v;
  w = edge.w;
  delete this._edgeLabels[e];
  delete this._edgeObjs[e];
  decrementOrRemoveEntry(this._preds[w], v);
  decrementOrRemoveEntry(this._sucs[v], w);
  delete this._in[w][e];
  delete this._out[v][e];
  this._edgeCount--;
}
return this;

};

Graph.prototype.inEdges = function(v, u) {

var inV = this._in[v];
if (inV) {
  var edges = _.values(inV);
  if (!u) {
    return edges;
  }
  return _.filter(edges, function(edge) { return edge.v === u; });
}

};

Graph.prototype.outEdges = function(v, w) {

var outV = this._out[v];
if (outV) {
  var edges = _.values(outV);
  if (!w) {
    return edges;
  }
  return _.filter(edges, function(edge) { return edge.w === w; });
}

};

Graph.prototype.nodeEdges = function(v, w) {

var inEdges = this.inEdges(v, w);
if (inEdges) {
  return inEdges.concat(this.outEdges(v, w));
}

};

function incrementOrInitEntry(map, k) {

if (map[k]) {
  map[k]++;
} else {
  map[k] = 1;
}

}

function decrementOrRemoveEntry(map, k) {

if (!--map[k]) { delete map[k]; }

}

function edgeArgsToId(isDirected, v_, w_, name) {

var v = "" + v_;
var w = "" + w_;
if (!isDirected && v > w) {
  var tmp = v;
  v = w;
  w = tmp;
}
return v + EDGE_KEY_DELIM + w + EDGE_KEY_DELIM +
           (_.isUndefined(name) ? DEFAULT_EDGE_NAME : name);

}

function edgeArgsToObj(isDirected, v_, w_, name) {

var v = "" + v_;
var w = "" + w_;
if (!isDirected && v > w) {
  var tmp = v;
  v = w;
  w = tmp;
}
var edgeObj =  { v: v, w: w };
if (name) {
  edgeObj.name = name;
}
return edgeObj;

}

function edgeObjToId(isDirected, edgeObj) {

return edgeArgsToId(isDirected, edgeObj.v, edgeObj.w, edgeObj.name);

}

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

/** Used as references for various `Number` constants. */ var MAX_SAFE_INTEGER = 9007199254740991;

/** Used to detect unsigned integer values. */ var reIsUint = /^(?:0|d*)$/;

/**

* Checks if `value` is a valid array-like index.
*
* @private
* @param {*} value The value to check.
* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
*/

function isIndex(value, length) {

length = length == null ? MAX_SAFE_INTEGER : length;
return !!length &&
  (typeof value == 'number' || reIsUint.test(value)) &&
  (value > -1 && value % 1 == 0 && value < length);

}

module.exports = isIndex;

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

/** Used as references for various `Number` constants. */ var MAX_SAFE_INTEGER = 9007199254740991;

/**

* Checks if `value` is a valid array-like length.
*
* **Note:** This method is loosely based on
* [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
* @example
*
* _.isLength(3);
* // => true
*
* _.isLength(Number.MIN_VALUE);
* // => false
*
* _.isLength(Infinity);
* // => false
*
* _.isLength('3');
* // => false
*/

function isLength(value) {

return typeof value == 'number' &&
  value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;

}

module.exports = isLength;

/***/ }), /* 34 */ /***/ (function(module, exports, webpack_require) {

var getNative = webpack_require(10),

root = __webpack_require__(5);

/* Built-in method references that are verified to be native. */ var Map = getNative(root, 'Map');

module.exports = Map;

/***/ }), /* 35 */ /***/ (function(module, exports, webpack_require) {

var mapCacheClear = webpack_require(274),

mapCacheDelete = __webpack_require__(281),
mapCacheGet = __webpack_require__(283),
mapCacheHas = __webpack_require__(284),
mapCacheSet = __webpack_require__(285);

/**

* Creates a map cache object to store key-value pairs.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/

function MapCache(entries) {

var index = -1,
    length = entries == null ? 0 : entries.length;

this.clear();
while (++index < length) {
  var entry = entries[index];
  this.set(entry[0], entry[1]);
}

}

// Add methods to `MapCache`. MapCache.prototype.clear = mapCacheClear; MapCache.prototype = mapCacheDelete; MapCache.prototype.get = mapCacheGet; MapCache.prototype.has = mapCacheHas; MapCache.prototype.set = mapCacheSet;

module.exports = MapCache;

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

/**

* 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;

}

module.exports = setToArray;

/***/ }), /* 37 */ /***/ (function(module, exports, webpack_require) {

var isArray = webpack_require(2),

isSymbol = __webpack_require__(16);

/** Used to match property names within property paths. */ var reIsDeepProp = /.|[(?:[^[]]*|([“'])(?:(?!1)|\.)*?1)]/,

reIsPlainProp = /^\w*$/;

/**

* Checks if `value` is a property name and not a property path.
*
* @private
* @param {*} value The value to check.
* @param {Object} [object] The object to query keys on.
* @returns {boolean} Returns `true` if `value` is a property name, else `false`.
*/

function isKey(value, object) {

if (isArray(value)) {
  return false;
}
var type = typeof value;
if (type == 'number' || type == 'symbol' || type == 'boolean' ||
    value == null || isSymbol(value)) {
  return true;
}
return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
  (object != null && value in Object(object));

}

module.exports = isKey;

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

/**

* A specialized version of `_.map` 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 the new mapped array.
*/

function arrayMap(array, iteratee) {

var index = -1,
    length = array == null ? 0 : array.length,
    result = Array(length);

while (++index < length) {
  result[index] = iteratee(array[index], index, array);
}
return result;

}

module.exports = arrayMap;

/***/ }), /* 39 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Afrikaans [af] //! author : Werner Mollentze : github.com/wernerm

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var af = moment.defineLocale('af', {

months : 'Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember'.split('_'),
monthsShort : 'Jan_Feb_Mrt_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des'.split('_'),
weekdays : 'Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag'.split('_'),
weekdaysShort : 'Son_Maa_Din_Woe_Don_Vry_Sat'.split('_'),
weekdaysMin : 'So_Ma_Di_Wo_Do_Vr_Sa'.split('_'),
meridiemParse: /vm|nm/i,
isPM : function (input) {
    return /^nm$/i.test(input);
},
meridiem : function (hours, minutes, isLower) {
    if (hours < 12) {
        return isLower ? 'vm' : 'VM';
    } else {
        return isLower ? 'nm' : 'NM';
    }
},
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
calendar : {
    sameDay : '[Vandag om] LT',
    nextDay : '[Môre om] LT',
    nextWeek : 'dddd [om] LT',
    lastDay : '[Gister om] LT',
    lastWeek : '[Laas] dddd [om] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'oor %s',
    past : '%s gelede',
    s : '\'n paar sekondes',
    m : '\'n minuut',
    mm : '%d minute',
    h : '\'n uur',
    hh : '%d ure',
    d : '\'n dag',
    dd : '%d dae',
    M : '\'n maand',
    MM : '%d maande',
    y : '\'n jaar',
    yy : '%d jaar'
},
dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
ordinal : function (number) {
    return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de'); // Thanks to Joris Röling : https://github.com/jjupiter
},
week : {
    dow : 1, // Maandag is die eerste dag van die week.
    doy : 4  // Die week wat die 4de Januarie bevat is die eerste week van die jaar.
}

});

return af;

})));

/***/ }), /* 40 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Arabic [ar] //! author : Abdel Said: github.com/abdelsaid //! author : Ahmed Elkhatib //! author : forabi github.com/forabi

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var symbolMap = {

'1': '١',
'2': '٢',
'3': '٣',
'4': '٤',
'5': '٥',
'6': '٦',
'7': '٧',
'8': '٨',
'9': '٩',
'0': '٠'

}; var numberMap = {

'١': '1',
'٢': '2',
'٣': '3',
'٤': '4',
'٥': '5',
'٦': '6',
'٧': '7',
'٨': '8',
'٩': '9',
'٠': '0'

}; var pluralForm = function (n) {

return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5;

}; var plurals = {

s : ['أقل من ثانية', 'ثانية واحدة', ['ثانيتان', 'ثانيتين'], '%d ثوان', '%d ثانية', '%d ثانية'],
m : ['أقل من دقيقة', 'دقيقة واحدة', ['دقيقتان', 'دقيقتين'], '%d دقائق', '%d دقيقة', '%d دقيقة'],
h : ['أقل من ساعة', 'ساعة واحدة', ['ساعتان', 'ساعتين'], '%d ساعات', '%d ساعة', '%d ساعة'],
d : ['أقل من يوم', 'يوم واحد', ['يومان', 'يومين'], '%d أيام', '%d يومًا', '%d يوم'],
M : ['أقل من شهر', 'شهر واحد', ['شهران', 'شهرين'], '%d أشهر', '%d شهرا', '%d شهر'],
y : ['أقل من عام', 'عام واحد', ['عامان', 'عامين'], '%d أعوام', '%d عامًا', '%d عام']

}; var pluralize = function (u) {

return function (number, withoutSuffix, string, isFuture) {
    var f = pluralForm(number),
        str = plurals[u][pluralForm(number)];
    if (f === 2) {
        str = str[withoutSuffix ? 0 : 1];
    }
    return str.replace(/%d/i, number);
};

}; var months = [

'كانون الثاني يناير',
'شباط فبراير',
'آذار مارس',
'نيسان أبريل',
'أيار مايو',
'حزيران يونيو',
'تموز يوليو',
'آب أغسطس',
'أيلول سبتمبر',
'تشرين الأول أكتوبر',
'تشرين الثاني نوفمبر',
'كانون الأول ديسمبر'

];

var ar = moment.defineLocale('ar', {

months : months,
monthsShort : months,
weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'D/\u200FM/\u200FYYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
meridiemParse: /ص|م/,
isPM : function (input) {
    return 'م' === input;
},
meridiem : function (hour, minute, isLower) {
    if (hour < 12) {
        return 'ص';
    } else {
        return 'م';
    }
},
calendar : {
    sameDay: '[اليوم عند الساعة] LT',
    nextDay: '[غدًا عند الساعة] LT',
    nextWeek: 'dddd [عند الساعة] LT',
    lastDay: '[أمس عند الساعة] LT',
    lastWeek: 'dddd [عند الساعة] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'بعد %s',
    past : 'منذ %s',
    s : pluralize('s'),
    m : pluralize('m'),
    mm : pluralize('m'),
    h : pluralize('h'),
    hh : pluralize('h'),
    d : pluralize('d'),
    dd : pluralize('d'),
    M : pluralize('M'),
    MM : pluralize('M'),
    y : pluralize('y'),
    yy : pluralize('y')
},
preparse: function (string) {
    return string.replace(/\u200f/g, '').replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
        return numberMap[match];
    }).replace(/،/g, ',');
},
postformat: function (string) {
    return string.replace(/\d/g, function (match) {
        return symbolMap[match];
    }).replace(/,/g, '،');
},
week : {
    dow : 6, // Saturday is the first day of the week.
    doy : 12  // The week that contains Jan 1st is the first week of the year.
}

});

return ar;

})));

/***/ }), /* 41 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Arabic (Algeria) [ar-dz] //! author : Noureddine LOUAHEDJ : github.com/noureddineme

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var arDz = moment.defineLocale('ar-dz', {

months : 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
monthsShort : 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
weekdaysShort : 'احد_اثنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
weekdaysMin : 'أح_إث_ثلا_أر_خم_جم_سب'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
calendar : {
    sameDay: '[اليوم على الساعة] LT',
    nextDay: '[غدا على الساعة] LT',
    nextWeek: 'dddd [على الساعة] LT',
    lastDay: '[أمس على الساعة] LT',
    lastWeek: 'dddd [على الساعة] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'في %s',
    past : 'منذ %s',
    s : 'ثوان',
    m : 'دقيقة',
    mm : '%d دقائق',
    h : 'ساعة',
    hh : '%d ساعات',
    d : 'يوم',
    dd : '%d أيام',
    M : 'شهر',
    MM : '%d أشهر',
    y : 'سنة',
    yy : '%d سنوات'
},
week : {
    dow : 0, // Sunday is the first day of the week.
    doy : 4  // The week that contains Jan 1st is the first week of the year.
}

});

return arDz;

})));

/***/ }), /* 42 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Arabic (Kuwait) [ar-kw] //! author : Nusret Parlak: github.com/nusretparlak

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var arKw = moment.defineLocale('ar-kw', {

months : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
monthsShort : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
weekdays : 'الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
weekdaysShort : 'احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
calendar : {
    sameDay: '[اليوم على الساعة] LT',
    nextDay: '[غدا على الساعة] LT',
    nextWeek: 'dddd [على الساعة] LT',
    lastDay: '[أمس على الساعة] LT',
    lastWeek: 'dddd [على الساعة] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'في %s',
    past : 'منذ %s',
    s : 'ثوان',
    m : 'دقيقة',
    mm : '%d دقائق',
    h : 'ساعة',
    hh : '%d ساعات',
    d : 'يوم',
    dd : '%d أيام',
    M : 'شهر',
    MM : '%d أشهر',
    y : 'سنة',
    yy : '%d سنوات'
},
week : {
    dow : 0, // Sunday is the first day of the week.
    doy : 12  // The week that contains Jan 1st is the first week of the year.
}

});

return arKw;

})));

/***/ }), /* 43 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Arabic (Lybia) [ar-ly] //! author : Ali Hmer: github.com/kikoanis

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var symbolMap = {

'1': '1',
'2': '2',
'3': '3',
'4': '4',
'5': '5',
'6': '6',
'7': '7',
'8': '8',
'9': '9',
'0': '0'

}; var pluralForm = function (n) {

return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5;

}; var plurals = {

s : ['أقل من ثانية', 'ثانية واحدة', ['ثانيتان', 'ثانيتين'], '%d ثوان', '%d ثانية', '%d ثانية'],
m : ['أقل من دقيقة', 'دقيقة واحدة', ['دقيقتان', 'دقيقتين'], '%d دقائق', '%d دقيقة', '%d دقيقة'],
h : ['أقل من ساعة', 'ساعة واحدة', ['ساعتان', 'ساعتين'], '%d ساعات', '%d ساعة', '%d ساعة'],
d : ['أقل من يوم', 'يوم واحد', ['يومان', 'يومين'], '%d أيام', '%d يومًا', '%d يوم'],
M : ['أقل من شهر', 'شهر واحد', ['شهران', 'شهرين'], '%d أشهر', '%d شهرا', '%d شهر'],
y : ['أقل من عام', 'عام واحد', ['عامان', 'عامين'], '%d أعوام', '%d عامًا', '%d عام']

}; var pluralize = function (u) {

return function (number, withoutSuffix, string, isFuture) {
    var f = pluralForm(number),
        str = plurals[u][pluralForm(number)];
    if (f === 2) {
        str = str[withoutSuffix ? 0 : 1];
    }
    return str.replace(/%d/i, number);
};

}; var months = [

'يناير',
'فبراير',
'مارس',
'أبريل',
'مايو',
'يونيو',
'يوليو',
'أغسطس',
'سبتمبر',
'أكتوبر',
'نوفمبر',
'ديسمبر'

];

var arLy = moment.defineLocale('ar-ly', {

months : months,
monthsShort : months,
weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'D/\u200FM/\u200FYYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
meridiemParse: /ص|م/,
isPM : function (input) {
    return 'م' === input;
},
meridiem : function (hour, minute, isLower) {
    if (hour < 12) {
        return 'ص';
    } else {
        return 'م';
    }
},
calendar : {
    sameDay: '[اليوم عند الساعة] LT',
    nextDay: '[غدًا عند الساعة] LT',
    nextWeek: 'dddd [عند الساعة] LT',
    lastDay: '[أمس عند الساعة] LT',
    lastWeek: 'dddd [عند الساعة] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'بعد %s',
    past : 'منذ %s',
    s : pluralize('s'),
    m : pluralize('m'),
    mm : pluralize('m'),
    h : pluralize('h'),
    hh : pluralize('h'),
    d : pluralize('d'),
    dd : pluralize('d'),
    M : pluralize('M'),
    MM : pluralize('M'),
    y : pluralize('y'),
    yy : pluralize('y')
},
preparse: function (string) {
    return string.replace(/\u200f/g, '').replace(/،/g, ',');
},
postformat: function (string) {
    return string.replace(/\d/g, function (match) {
        return symbolMap[match];
    }).replace(/,/g, '،');
},
week : {
    dow : 6, // Saturday is the first day of the week.
    doy : 12  // The week that contains Jan 1st is the first week of the year.
}

});

return arLy;

})));

/***/ }), /* 44 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Arabic (Morocco) [ar-ma] //! author : ElFadili Yassine : github.com/ElFadiliY //! author : Abdel Said : github.com/abdelsaid

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var arMa = moment.defineLocale('ar-ma', {

months : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
monthsShort : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
weekdays : 'الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
weekdaysShort : 'احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
calendar : {
    sameDay: '[اليوم على الساعة] LT',
    nextDay: '[غدا على الساعة] LT',
    nextWeek: 'dddd [على الساعة] LT',
    lastDay: '[أمس على الساعة] LT',
    lastWeek: 'dddd [على الساعة] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'في %s',
    past : 'منذ %s',
    s : 'ثوان',
    m : 'دقيقة',
    mm : '%d دقائق',
    h : 'ساعة',
    hh : '%d ساعات',
    d : 'يوم',
    dd : '%d أيام',
    M : 'شهر',
    MM : '%d أشهر',
    y : 'سنة',
    yy : '%d سنوات'
},
week : {
    dow : 6, // Saturday is the first day of the week.
    doy : 12  // The week that contains Jan 1st is the first week of the year.
}

});

return arMa;

})));

/***/ }), /* 45 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Arabic (Saudi Arabia) [ar-sa] //! author : Suhail Alkowaileet : github.com/xsoh

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var symbolMap = {

'1': '١',
'2': '٢',
'3': '٣',
'4': '٤',
'5': '٥',
'6': '٦',
'7': '٧',
'8': '٨',
'9': '٩',
'0': '٠'

}; var numberMap = {

'١': '1',
'٢': '2',
'٣': '3',
'٤': '4',
'٥': '5',
'٦': '6',
'٧': '7',
'٨': '8',
'٩': '9',
'٠': '0'

};

var arSa = moment.defineLocale('ar-sa', {

months : 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
monthsShort : 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
meridiemParse: /ص|م/,
isPM : function (input) {
    return 'م' === input;
},
meridiem : function (hour, minute, isLower) {
    if (hour < 12) {
        return 'ص';
    } else {
        return 'م';
    }
},
calendar : {
    sameDay: '[اليوم على الساعة] LT',
    nextDay: '[غدا على الساعة] LT',
    nextWeek: 'dddd [على الساعة] LT',
    lastDay: '[أمس على الساعة] LT',
    lastWeek: 'dddd [على الساعة] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'في %s',
    past : 'منذ %s',
    s : 'ثوان',
    m : 'دقيقة',
    mm : '%d دقائق',
    h : 'ساعة',
    hh : '%d ساعات',
    d : 'يوم',
    dd : '%d أيام',
    M : 'شهر',
    MM : '%d أشهر',
    y : 'سنة',
    yy : '%d سنوات'
},
preparse: function (string) {
    return string.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
        return numberMap[match];
    }).replace(/،/g, ',');
},
postformat: function (string) {
    return string.replace(/\d/g, function (match) {
        return symbolMap[match];
    }).replace(/,/g, '،');
},
week : {
    dow : 0, // Sunday is the first day of the week.
    doy : 6  // The week that contains Jan 1st is the first week of the year.
}

});

return arSa;

})));

/***/ }), /* 46 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Arabic (Tunisia) [ar-tn] //! author : Nader Toukabri : github.com/naderio

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var arTn = moment.defineLocale('ar-tn', {

months: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
monthsShort: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
weekdays: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
weekdaysShort: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
weekdaysMin: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
weekdaysParseExact : true,
longDateFormat: {
    LT: 'HH:mm',
    LTS: 'HH:mm:ss',
    L: 'DD/MM/YYYY',
    LL: 'D MMMM YYYY',
    LLL: 'D MMMM YYYY HH:mm',
    LLLL: 'dddd D MMMM YYYY HH:mm'
},
calendar: {
    sameDay: '[اليوم على الساعة] LT',
    nextDay: '[غدا على الساعة] LT',
    nextWeek: 'dddd [على الساعة] LT',
    lastDay: '[أمس على الساعة] LT',
    lastWeek: 'dddd [على الساعة] LT',
    sameElse: 'L'
},
relativeTime: {
    future: 'في %s',
    past: 'منذ %s',
    s: 'ثوان',
    m: 'دقيقة',
    mm: '%d دقائق',
    h: 'ساعة',
    hh: '%d ساعات',
    d: 'يوم',
    dd: '%d أيام',
    M: 'شهر',
    MM: '%d أشهر',
    y: 'سنة',
    yy: '%d سنوات'
},
week: {
    dow: 1, // Monday is the first day of the week.
    doy: 4 // The week that contains Jan 4th is the first week of the year.
}

});

return arTn;

})));

/***/ }), /* 47 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Azerbaijani [az] //! author : topchiyev : github.com/topchiyev

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var suffixes = {

1: '-inci',
5: '-inci',
8: '-inci',
70: '-inci',
80: '-inci',
2: '-nci',
7: '-nci',
20: '-nci',
50: '-nci',
3: '-üncü',
4: '-üncü',
100: '-üncü',
6: '-ncı',
9: '-uncu',
10: '-uncu',
30: '-uncu',
60: '-ıncı',
90: '-ıncı'

};

var az = moment.defineLocale('az', {

months : 'yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr'.split('_'),
monthsShort : 'yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek'.split('_'),
weekdays : 'Bazar_Bazar ertəsi_Çərşənbə axşamı_Çərşənbə_Cümə axşamı_Cümə_Şənbə'.split('_'),
weekdaysShort : 'Baz_BzE_ÇAx_Çər_CAx_Cüm_Şən'.split('_'),
weekdaysMin : 'Bz_BE_ÇA_Çə_CA_Cü_Şə'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
calendar : {
    sameDay : '[bugün saat] LT',
    nextDay : '[sabah saat] LT',
    nextWeek : '[gələn həftə] dddd [saat] LT',
    lastDay : '[dünən] LT',
    lastWeek : '[keçən həftə] dddd [saat] LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s sonra',
    past : '%s əvvəl',
    s : 'birneçə saniyyə',
    m : 'bir dəqiqə',
    mm : '%d dəqiqə',
    h : 'bir saat',
    hh : '%d saat',
    d : 'bir gün',
    dd : '%d gün',
    M : 'bir ay',
    MM : '%d ay',
    y : 'bir il',
    yy : '%d il'
},
meridiemParse: /gecə|səhər|gündüz|axşam/,
isPM : function (input) {
    return /^(gündüz|axşam)$/.test(input);
},
meridiem : function (hour, minute, isLower) {
    if (hour < 4) {
        return 'gecə';
    } else if (hour < 12) {
        return 'səhər';
    } else if (hour < 17) {
        return 'gündüz';
    } else {
        return 'axşam';
    }
},
dayOfMonthOrdinalParse: /\d{1,2}-(ıncı|inci|nci|üncü|ncı|uncu)/,
ordinal : function (number) {
    if (number === 0) {  // special case for zero
        return number + '-ıncı';
    }
    var a = number % 10,
        b = number % 100 - a,
        c = number >= 100 ? 100 : null;
    return number + (suffixes[a] || suffixes[b] || suffixes[c]);
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return az;

})));

/***/ }), /* 48 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Belarusian [be] //! author : Dmitry Demidov : github.com/demidov91 //! author: Praleska: praleska.pro/ //! Author : Menelion Elensúle : github.com/Oire

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function plural(word, num) {

var forms = word.split('_');
return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);

} function relativeTimeWithPlural(number, withoutSuffix, key) {

var format = {
    'mm': withoutSuffix ? 'хвіліна_хвіліны_хвілін' : 'хвіліну_хвіліны_хвілін',
    'hh': withoutSuffix ? 'гадзіна_гадзіны_гадзін' : 'гадзіну_гадзіны_гадзін',
    'dd': 'дзень_дні_дзён',
    'MM': 'месяц_месяцы_месяцаў',
    'yy': 'год_гады_гадоў'
};
if (key === 'm') {
    return withoutSuffix ? 'хвіліна' : 'хвіліну';
}
else if (key === 'h') {
    return withoutSuffix ? 'гадзіна' : 'гадзіну';
}
else {
    return number + ' ' + plural(format[key], +number);
}

}

var be = moment.defineLocale('be', {

months : {
    format: 'студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня'.split('_'),
    standalone: 'студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань'.split('_')
},
monthsShort : 'студ_лют_сак_крас_трав_чэрв_ліп_жнів_вер_каст_ліст_снеж'.split('_'),
weekdays : {
    format: 'нядзелю_панядзелак_аўторак_сераду_чацвер_пятніцу_суботу'.split('_'),
    standalone: 'нядзеля_панядзелак_аўторак_серада_чацвер_пятніца_субота'.split('_'),
    isFormat: /\[ ?[Вв] ?(?:мінулую|наступную)? ?\] ?dddd/
},
weekdaysShort : 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
weekdaysMin : 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D MMMM YYYY г.',
    LLL : 'D MMMM YYYY г., HH:mm',
    LLLL : 'dddd, D MMMM YYYY г., HH:mm'
},
calendar : {
    sameDay: '[Сёння ў] LT',
    nextDay: '[Заўтра ў] LT',
    lastDay: '[Учора ў] LT',
    nextWeek: function () {
        return '[У] dddd [ў] LT';
    },
    lastWeek: function () {
        switch (this.day()) {
            case 0:
            case 3:
            case 5:
            case 6:
                return '[У мінулую] dddd [ў] LT';
            case 1:
            case 2:
            case 4:
                return '[У мінулы] dddd [ў] LT';
        }
    },
    sameElse: 'L'
},
relativeTime : {
    future : 'праз %s',
    past : '%s таму',
    s : 'некалькі секунд',
    m : relativeTimeWithPlural,
    mm : relativeTimeWithPlural,
    h : relativeTimeWithPlural,
    hh : relativeTimeWithPlural,
    d : 'дзень',
    dd : relativeTimeWithPlural,
    M : 'месяц',
    MM : relativeTimeWithPlural,
    y : 'год',
    yy : relativeTimeWithPlural
},
meridiemParse: /ночы|раніцы|дня|вечара/,
isPM : function (input) {
    return /^(дня|вечара)$/.test(input);
},
meridiem : function (hour, minute, isLower) {
    if (hour < 4) {
        return 'ночы';
    } else if (hour < 12) {
        return 'раніцы';
    } else if (hour < 17) {
        return 'дня';
    } else {
        return 'вечара';
    }
},
dayOfMonthOrdinalParse: /\d{1,2}-(і|ы|га)/,
ordinal: function (number, period) {
    switch (period) {
        case 'M':
        case 'd':
        case 'DDD':
        case 'w':
        case 'W':
            return (number % 10 === 2 || number % 10 === 3) && (number % 100 !== 12 && number % 100 !== 13) ? number + '-і' : number + '-ы';
        case 'D':
            return number + '-га';
        default:
            return number;
    }
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return be;

})));

/***/ }), /* 49 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Bulgarian [bg] //! author : Krasen Borisov : github.com/kraz

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var bg = moment.defineLocale('bg', {

months : 'януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември'.split('_'),
monthsShort : 'янр_фев_мар_апр_май_юни_юли_авг_сеп_окт_ное_дек'.split('_'),
weekdays : 'неделя_понеделник_вторник_сряда_четвъртък_петък_събота'.split('_'),
weekdaysShort : 'нед_пон_вто_сря_чет_пет_съб'.split('_'),
weekdaysMin : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
longDateFormat : {
    LT : 'H:mm',
    LTS : 'H:mm:ss',
    L : 'D.MM.YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY H:mm',
    LLLL : 'dddd, D MMMM YYYY H:mm'
},
calendar : {
    sameDay : '[Днес в] LT',
    nextDay : '[Утре в] LT',
    nextWeek : 'dddd [в] LT',
    lastDay : '[Вчера в] LT',
    lastWeek : function () {
        switch (this.day()) {
            case 0:
            case 3:
            case 6:
                return '[В изминалата] dddd [в] LT';
            case 1:
            case 2:
            case 4:
            case 5:
                return '[В изминалия] dddd [в] LT';
        }
    },
    sameElse : 'L'
},
relativeTime : {
    future : 'след %s',
    past : 'преди %s',
    s : 'няколко секунди',
    m : 'минута',
    mm : '%d минути',
    h : 'час',
    hh : '%d часа',
    d : 'ден',
    dd : '%d дни',
    M : 'месец',
    MM : '%d месеца',
    y : 'година',
    yy : '%d години'
},
dayOfMonthOrdinalParse: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
ordinal : function (number) {
    var lastDigit = number % 10,
        last2Digits = number % 100;
    if (number === 0) {
        return number + '-ев';
    } else if (last2Digits === 0) {
        return number + '-ен';
    } else if (last2Digits > 10 && last2Digits < 20) {
        return number + '-ти';
    } else if (lastDigit === 1) {
        return number + '-ви';
    } else if (lastDigit === 2) {
        return number + '-ри';
    } else if (lastDigit === 7 || lastDigit === 8) {
        return number + '-ми';
    } else {
        return number + '-ти';
    }
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return bg;

})));

/***/ }), /* 50 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Bengali [bn] //! author : Kaushik Gandhi : github.com/kaushikgandhi

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var symbolMap = {

'1': '১',
'2': '২',
'3': '৩',
'4': '৪',
'5': '৫',
'6': '৬',
'7': '৭',
'8': '৮',
'9': '৯',
'0': '০'

}; var numberMap = {

'১': '1',
'২': '2',
'৩': '3',
'৪': '4',
'৫': '5',
'৬': '6',
'৭': '7',
'৮': '8',
'৯': '9',
'০': '0'

};

var bn = moment.defineLocale('bn', {

months : 'জানুয়ারী_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর'.split('_'),
monthsShort : 'জানু_ফেব_মার্চ_এপ্র_মে_জুন_জুল_আগ_সেপ্ট_অক্টো_নভে_ডিসে'.split('_'),
weekdays : 'রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার'.split('_'),
weekdaysShort : 'রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি'.split('_'),
weekdaysMin : 'রবি_সোম_মঙ্গ_বুধ_বৃহঃ_শুক্র_শনি'.split('_'),
longDateFormat : {
    LT : 'A h:mm সময়',
    LTS : 'A h:mm:ss সময়',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY, A h:mm সময়',
    LLLL : 'dddd, D MMMM YYYY, A h:mm সময়'
},
calendar : {
    sameDay : '[আজ] LT',
    nextDay : '[আগামীকাল] LT',
    nextWeek : 'dddd, LT',
    lastDay : '[গতকাল] LT',
    lastWeek : '[গত] dddd, LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s পরে',
    past : '%s আগে',
    s : 'কয়েক সেকেন্ড',
    m : 'এক মিনিট',
    mm : '%d মিনিট',
    h : 'এক ঘন্টা',
    hh : '%d ঘন্টা',
    d : 'এক দিন',
    dd : '%d দিন',
    M : 'এক মাস',
    MM : '%d মাস',
    y : 'এক বছর',
    yy : '%d বছর'
},
preparse: function (string) {
    return string.replace(/[১২৩৪৫৬৭৮৯০]/g, function (match) {
        return numberMap[match];
    });
},
postformat: function (string) {
    return string.replace(/\d/g, function (match) {
        return symbolMap[match];
    });
},
meridiemParse: /রাত|সকাল|দুপুর|বিকাল|রাত/,
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if ((meridiem === 'রাত' && hour >= 4) ||
            (meridiem === 'দুপুর' && hour < 5) ||
            meridiem === 'বিকাল') {
        return hour + 12;
    } else {
        return hour;
    }
},
meridiem : function (hour, minute, isLower) {
    if (hour < 4) {
        return 'রাত';
    } else if (hour < 10) {
        return 'সকাল';
    } else if (hour < 17) {
        return 'দুপুর';
    } else if (hour < 20) {
        return 'বিকাল';
    } else {
        return 'রাত';
    }
},
week : {
    dow : 0, // Sunday is the first day of the week.
    doy : 6  // The week that contains Jan 1st is the first week of the year.
}

});

return bn;

})));

/***/ }), /* 51 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Tibetan [bo] //! author : Thupten N. Chakrishar : github.com/vajradog

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var symbolMap = {

'1': '༡',
'2': '༢',
'3': '༣',
'4': '༤',
'5': '༥',
'6': '༦',
'7': '༧',
'8': '༨',
'9': '༩',
'0': '༠'

}; var numberMap = {

'༡': '1',
'༢': '2',
'༣': '3',
'༤': '4',
'༥': '5',
'༦': '6',
'༧': '7',
'༨': '8',
'༩': '9',
'༠': '0'

};

var bo = moment.defineLocale('bo', {

months : 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
monthsShort : 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
weekdays : 'གཟའ་ཉི་མ་_གཟའ་ཟླ་བ་_གཟའ་མིག་དམར་_གཟའ་ལྷག་པ་_གཟའ་ཕུར་བུ_གཟའ་པ་སངས་_གཟའ་སྤེན་པ་'.split('_'),
weekdaysShort : 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
weekdaysMin : 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
longDateFormat : {
    LT : 'A h:mm',
    LTS : 'A h:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY, A h:mm',
    LLLL : 'dddd, D MMMM YYYY, A h:mm'
},
calendar : {
    sameDay : '[དི་རིང] LT',
    nextDay : '[སང་ཉིན] LT',
    nextWeek : '[བདུན་ཕྲག་རྗེས་མ], LT',
    lastDay : '[ཁ་སང] LT',
    lastWeek : '[བདུན་ཕྲག་མཐའ་མ] dddd, LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s ལ་',
    past : '%s སྔན་ལ',
    s : 'ལམ་སང',
    m : 'སྐར་མ་གཅིག',
    mm : '%d སྐར་མ',
    h : 'ཆུ་ཚོད་གཅིག',
    hh : '%d ཆུ་ཚོད',
    d : 'ཉིན་གཅིག',
    dd : '%d ཉིན་',
    M : 'ཟླ་བ་གཅིག',
    MM : '%d ཟླ་བ',
    y : 'ལོ་གཅིག',
    yy : '%d ལོ'
},
preparse: function (string) {
    return string.replace(/[༡༢༣༤༥༦༧༨༩༠]/g, function (match) {
        return numberMap[match];
    });
},
postformat: function (string) {
    return string.replace(/\d/g, function (match) {
        return symbolMap[match];
    });
},
meridiemParse: /མཚན་མོ|ཞོགས་ཀས|ཉིན་གུང|དགོང་དག|མཚན་མོ/,
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if ((meridiem === 'མཚན་མོ' && hour >= 4) ||
            (meridiem === 'ཉིན་གུང' && hour < 5) ||
            meridiem === 'དགོང་དག') {
        return hour + 12;
    } else {
        return hour;
    }
},
meridiem : function (hour, minute, isLower) {
    if (hour < 4) {
        return 'མཚན་མོ';
    } else if (hour < 10) {
        return 'ཞོགས་ཀས';
    } else if (hour < 17) {
        return 'ཉིན་གུང';
    } else if (hour < 20) {
        return 'དགོང་དག';
    } else {
        return 'མཚན་མོ';
    }
},
week : {
    dow : 0, // Sunday is the first day of the week.
    doy : 6  // The week that contains Jan 1st is the first week of the year.
}

});

return bo;

})));

/***/ }), /* 52 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Breton [br] //! author : Jean-Baptiste Le Duigou : github.com/jbleduigou

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function relativeTimeWithMutation(number, withoutSuffix, key) {

var format = {
    'mm': 'munutenn',
    'MM': 'miz',
    'dd': 'devezh'
};
return number + ' ' + mutation(format[key], number);

} function specialMutationForYears(number) {

switch (lastNumber(number)) {
    case 1:
    case 3:
    case 4:
    case 5:
    case 9:
        return number + ' bloaz';
    default:
        return number + ' vloaz';
}

} function lastNumber(number) {

if (number > 9) {
    return lastNumber(number % 10);
}
return number;

} function mutation(text, number) {

if (number === 2) {
    return softMutation(text);
}
return text;

} function softMutation(text) {

var mutationTable = {
    'm': 'v',
    'b': 'v',
    'd': 'z'
};
if (mutationTable[text.charAt(0)] === undefined) {
    return text;
}
return mutationTable[text.charAt(0)] + text.substring(1);

}

var br = moment.defineLocale('br', {

months : 'Genver_C\'hwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu'.split('_'),
monthsShort : 'Gen_C\'hwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker'.split('_'),
weekdays : 'Sul_Lun_Meurzh_Merc\'her_Yaou_Gwener_Sadorn'.split('_'),
weekdaysShort : 'Sul_Lun_Meu_Mer_Yao_Gwe_Sad'.split('_'),
weekdaysMin : 'Su_Lu_Me_Mer_Ya_Gw_Sa'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'h[e]mm A',
    LTS : 'h[e]mm:ss A',
    L : 'DD/MM/YYYY',
    LL : 'D [a viz] MMMM YYYY',
    LLL : 'D [a viz] MMMM YYYY h[e]mm A',
    LLLL : 'dddd, D [a viz] MMMM YYYY h[e]mm A'
},
calendar : {
    sameDay : '[Hiziv da] LT',
    nextDay : '[Warc\'hoazh da] LT',
    nextWeek : 'dddd [da] LT',
    lastDay : '[Dec\'h da] LT',
    lastWeek : 'dddd [paset da] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'a-benn %s',
    past : '%s \'zo',
    s : 'un nebeud segondennoù',
    m : 'ur vunutenn',
    mm : relativeTimeWithMutation,
    h : 'un eur',
    hh : '%d eur',
    d : 'un devezh',
    dd : relativeTimeWithMutation,
    M : 'ur miz',
    MM : relativeTimeWithMutation,
    y : 'ur bloaz',
    yy : specialMutationForYears
},
dayOfMonthOrdinalParse: /\d{1,2}(añ|vet)/,
ordinal : function (number) {
    var output = (number === 1) ? 'añ' : 'vet';
    return number + output;
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return br;

})));

/***/ }), /* 53 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Bosnian [bs] //! author : Nedim Cholich : github.com/frontyard //! based on (hr) translation by Bojan Marković

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function translate(number, withoutSuffix, key) {

var result = number + ' ';
switch (key) {
    case 'm':
        return withoutSuffix ? 'jedna minuta' : 'jedne minute';
    case 'mm':
        if (number === 1) {
            result += 'minuta';
        } else if (number === 2 || number === 3 || number === 4) {
            result += 'minute';
        } else {
            result += 'minuta';
        }
        return result;
    case 'h':
        return withoutSuffix ? 'jedan sat' : 'jednog sata';
    case 'hh':
        if (number === 1) {
            result += 'sat';
        } else if (number === 2 || number === 3 || number === 4) {
            result += 'sata';
        } else {
            result += 'sati';
        }
        return result;
    case 'dd':
        if (number === 1) {
            result += 'dan';
        } else {
            result += 'dana';
        }
        return result;
    case 'MM':
        if (number === 1) {
            result += 'mjesec';
        } else if (number === 2 || number === 3 || number === 4) {
            result += 'mjeseca';
        } else {
            result += 'mjeseci';
        }
        return result;
    case 'yy':
        if (number === 1) {
            result += 'godina';
        } else if (number === 2 || number === 3 || number === 4) {
            result += 'godine';
        } else {
            result += 'godina';
        }
        return result;
}

}

var bs = moment.defineLocale('bs', {

months : 'januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar'.split('_'),
monthsShort : 'jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.'.split('_'),
monthsParseExact: true,
weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
weekdaysShort : 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
weekdaysMin : 'ne_po_ut_sr_če_pe_su'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'H:mm',
    LTS : 'H:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D. MMMM YYYY',
    LLL : 'D. MMMM YYYY H:mm',
    LLLL : 'dddd, D. MMMM YYYY H:mm'
},
calendar : {
    sameDay  : '[danas u] LT',
    nextDay  : '[sutra u] LT',
    nextWeek : function () {
        switch (this.day()) {
            case 0:
                return '[u] [nedjelju] [u] LT';
            case 3:
                return '[u] [srijedu] [u] LT';
            case 6:
                return '[u] [subotu] [u] LT';
            case 1:
            case 2:
            case 4:
            case 5:
                return '[u] dddd [u] LT';
        }
    },
    lastDay  : '[jučer u] LT',
    lastWeek : function () {
        switch (this.day()) {
            case 0:
            case 3:
                return '[prošlu] dddd [u] LT';
            case 6:
                return '[prošle] [subote] [u] LT';
            case 1:
            case 2:
            case 4:
            case 5:
                return '[prošli] dddd [u] LT';
        }
    },
    sameElse : 'L'
},
relativeTime : {
    future : 'za %s',
    past   : 'prije %s',
    s      : 'par sekundi',
    m      : translate,
    mm     : translate,
    h      : translate,
    hh     : translate,
    d      : 'dan',
    dd     : translate,
    M      : 'mjesec',
    MM     : translate,
    y      : 'godinu',
    yy     : translate
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return bs;

})));

/***/ }), /* 54 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Catalan [ca] //! author : Juan G. Hurtado : github.com/juanghurtado

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var ca = moment.defineLocale('ca', {

months : {
    standalone: 'gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre'.split('_'),
    format: 'de gener_de febrer_de març_d\'abril_de maig_de juny_de juliol_d\'agost_de setembre_d\'octubre_de novembre_de desembre'.split('_'),
    isFormat: /D[oD]?(\s)+MMMM/
},
monthsShort : 'gen._febr._març_abr._maig_juny_jul._ag._set._oct._nov._des.'.split('_'),
monthsParseExact : true,
weekdays : 'diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte'.split('_'),
weekdaysShort : 'dg._dl._dt._dc._dj._dv._ds.'.split('_'),
weekdaysMin : 'Dg_Dl_Dt_Dc_Dj_Dv_Ds'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'H:mm',
    LTS : 'H:mm:ss',
    L : 'DD/MM/YYYY',
    LL : '[el] D MMMM [de] YYYY',
    ll : 'D MMM YYYY',
    LLL : '[el] D MMMM [de] YYYY [a les] H:mm',
    lll : 'D MMM YYYY, H:mm',
    LLLL : '[el] dddd D MMMM [de] YYYY [a les] H:mm',
    llll : 'ddd D MMM YYYY, H:mm'
},
calendar : {
    sameDay : function () {
        return '[avui a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
    },
    nextDay : function () {
        return '[demà a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
    },
    nextWeek : function () {
        return 'dddd [a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
    },
    lastDay : function () {
        return '[ahir a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
    },
    lastWeek : function () {
        return '[el] dddd [passat a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
    },
    sameElse : 'L'
},
relativeTime : {
    future : 'd\'aquí %s',
    past : 'fa %s',
    s : 'uns segons',
    m : 'un minut',
    mm : '%d minuts',
    h : 'una hora',
    hh : '%d hores',
    d : 'un dia',
    dd : '%d dies',
    M : 'un mes',
    MM : '%d mesos',
    y : 'un any',
    yy : '%d anys'
},
dayOfMonthOrdinalParse: /\d{1,2}(r|n|t|è|a)/,
ordinal : function (number, period) {
    var output = (number === 1) ? 'r' :
        (number === 2) ? 'n' :
        (number === 3) ? 'r' :
        (number === 4) ? 't' : 'è';
    if (period === 'w' || period === 'W') {
        output = 'a';
    }
    return number + output;
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return ca;

})));

/***/ }), /* 55 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Czech [cs] //! author : petrbela : github.com/petrbela

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var months = 'leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec'.split('_'); var monthsShort = 'led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro'.split('_'); function plural(n) {

return (n > 1) && (n < 5) && (~~(n / 10) !== 1);

} function translate(number, withoutSuffix, key, isFuture) {

var result = number + ' ';
switch (key) {
    case 's':  // a few seconds / in a few seconds / a few seconds ago
        return (withoutSuffix || isFuture) ? 'pár sekund' : 'pár sekundami';
    case 'm':  // a minute / in a minute / a minute ago
        return withoutSuffix ? 'minuta' : (isFuture ? 'minutu' : 'minutou');
    case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
        if (withoutSuffix || isFuture) {
            return result + (plural(number) ? 'minuty' : 'minut');
        } else {
            return result + 'minutami';
        }
        break;
    case 'h':  // an hour / in an hour / an hour ago
        return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
    case 'hh': // 9 hours / in 9 hours / 9 hours ago
        if (withoutSuffix || isFuture) {
            return result + (plural(number) ? 'hodiny' : 'hodin');
        } else {
            return result + 'hodinami';
        }
        break;
    case 'd':  // a day / in a day / a day ago
        return (withoutSuffix || isFuture) ? 'den' : 'dnem';
    case 'dd': // 9 days / in 9 days / 9 days ago
        if (withoutSuffix || isFuture) {
            return result + (plural(number) ? 'dny' : 'dní');
        } else {
            return result + 'dny';
        }
        break;
    case 'M':  // a month / in a month / a month ago
        return (withoutSuffix || isFuture) ? 'měsíc' : 'měsícem';
    case 'MM': // 9 months / in 9 months / 9 months ago
        if (withoutSuffix || isFuture) {
            return result + (plural(number) ? 'měsíce' : 'měsíců');
        } else {
            return result + 'měsíci';
        }
        break;
    case 'y':  // a year / in a year / a year ago
        return (withoutSuffix || isFuture) ? 'rok' : 'rokem';
    case 'yy': // 9 years / in 9 years / 9 years ago
        if (withoutSuffix || isFuture) {
            return result + (plural(number) ? 'roky' : 'let');
        } else {
            return result + 'lety';
        }
        break;
}

}

var cs = moment.defineLocale('cs', {

months : months,
monthsShort : monthsShort,
monthsParse : (function (months, monthsShort) {
    var i, _monthsParse = [];
    for (i = 0; i < 12; i++) {
        // use custom parser to solve problem with July (červenec)
        _monthsParse[i] = new RegExp('^' + months[i] + '$|^' + monthsShort[i] + '$', 'i');
    }
    return _monthsParse;
}(months, monthsShort)),
shortMonthsParse : (function (monthsShort) {
    var i, _shortMonthsParse = [];
    for (i = 0; i < 12; i++) {
        _shortMonthsParse[i] = new RegExp('^' + monthsShort[i] + '$', 'i');
    }
    return _shortMonthsParse;
}(monthsShort)),
longMonthsParse : (function (months) {
    var i, _longMonthsParse = [];
    for (i = 0; i < 12; i++) {
        _longMonthsParse[i] = new RegExp('^' + months[i] + '$', 'i');
    }
    return _longMonthsParse;
}(months)),
weekdays : 'neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota'.split('_'),
weekdaysShort : 'ne_po_út_st_čt_pá_so'.split('_'),
weekdaysMin : 'ne_po_út_st_čt_pá_so'.split('_'),
longDateFormat : {
    LT: 'H:mm',
    LTS : 'H:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D. MMMM YYYY',
    LLL : 'D. MMMM YYYY H:mm',
    LLLL : 'dddd D. MMMM YYYY H:mm',
    l : 'D. M. YYYY'
},
calendar : {
    sameDay: '[dnes v] LT',
    nextDay: '[zítra v] LT',
    nextWeek: function () {
        switch (this.day()) {
            case 0:
                return '[v neděli v] LT';
            case 1:
            case 2:
                return '[v] dddd [v] LT';
            case 3:
                return '[ve středu v] LT';
            case 4:
                return '[ve čtvrtek v] LT';
            case 5:
                return '[v pátek v] LT';
            case 6:
                return '[v sobotu v] LT';
        }
    },
    lastDay: '[včera v] LT',
    lastWeek: function () {
        switch (this.day()) {
            case 0:
                return '[minulou neděli v] LT';
            case 1:
            case 2:
                return '[minulé] dddd [v] LT';
            case 3:
                return '[minulou středu v] LT';
            case 4:
            case 5:
                return '[minulý] dddd [v] LT';
            case 6:
                return '[minulou sobotu v] LT';
        }
    },
    sameElse: 'L'
},
relativeTime : {
    future : 'za %s',
    past : 'před %s',
    s : translate,
    m : translate,
    mm : translate,
    h : translate,
    hh : translate,
    d : translate,
    dd : translate,
    M : translate,
    MM : translate,
    y : translate,
    yy : translate
},
dayOfMonthOrdinalParse : /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return cs;

})));

/***/ }), /* 56 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Chuvash [cv] //! author : Anatoly Mironov : github.com/mirontoli

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var cv = moment.defineLocale('cv', {

months : 'кӑрлач_нарӑс_пуш_ака_май_ҫӗртме_утӑ_ҫурла_авӑн_юпа_чӳк_раштав'.split('_'),
monthsShort : 'кӑр_нар_пуш_ака_май_ҫӗр_утӑ_ҫур_авн_юпа_чӳк_раш'.split('_'),
weekdays : 'вырсарникун_тунтикун_ытларикун_юнкун_кӗҫнерникун_эрнекун_шӑматкун'.split('_'),
weekdaysShort : 'выр_тун_ытл_юн_кӗҫ_эрн_шӑм'.split('_'),
weekdaysMin : 'вр_тн_ыт_юн_кҫ_эр_шм'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD-MM-YYYY',
    LL : 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ]',
    LLL : 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm',
    LLLL : 'dddd, YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm'
},
calendar : {
    sameDay: '[Паян] LT [сехетре]',
    nextDay: '[Ыран] LT [сехетре]',
    lastDay: '[Ӗнер] LT [сехетре]',
    nextWeek: '[Ҫитес] dddd LT [сехетре]',
    lastWeek: '[Иртнӗ] dddd LT [сехетре]',
    sameElse: 'L'
},
relativeTime : {
    future : function (output) {
        var affix = /сехет$/i.exec(output) ? 'рен' : /ҫул$/i.exec(output) ? 'тан' : 'ран';
        return output + affix;
    },
    past : '%s каялла',
    s : 'пӗр-ик ҫеккунт',
    m : 'пӗр минут',
    mm : '%d минут',
    h : 'пӗр сехет',
    hh : '%d сехет',
    d : 'пӗр кун',
    dd : '%d кун',
    M : 'пӗр уйӑх',
    MM : '%d уйӑх',
    y : 'пӗр ҫул',
    yy : '%d ҫул'
},
dayOfMonthOrdinalParse: /\d{1,2}-мӗш/,
ordinal : '%d-мӗш',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return cv;

})));

/***/ }), /* 57 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Welsh [cy] //! author : Robert Allen : github.com/robgallen //! author : github.com/ryangreaves

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var cy = moment.defineLocale('cy', {

months: 'Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr'.split('_'),
monthsShort: 'Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag'.split('_'),
weekdays: 'Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn'.split('_'),
weekdaysShort: 'Sul_Llun_Maw_Mer_Iau_Gwe_Sad'.split('_'),
weekdaysMin: 'Su_Ll_Ma_Me_Ia_Gw_Sa'.split('_'),
weekdaysParseExact : true,
// time formats are the same as en-gb
longDateFormat: {
    LT: 'HH:mm',
    LTS : 'HH:mm:ss',
    L: 'DD/MM/YYYY',
    LL: 'D MMMM YYYY',
    LLL: 'D MMMM YYYY HH:mm',
    LLLL: 'dddd, D MMMM YYYY HH:mm'
},
calendar: {
    sameDay: '[Heddiw am] LT',
    nextDay: '[Yfory am] LT',
    nextWeek: 'dddd [am] LT',
    lastDay: '[Ddoe am] LT',
    lastWeek: 'dddd [diwethaf am] LT',
    sameElse: 'L'
},
relativeTime: {
    future: 'mewn %s',
    past: '%s yn ôl',
    s: 'ychydig eiliadau',
    m: 'munud',
    mm: '%d munud',
    h: 'awr',
    hh: '%d awr',
    d: 'diwrnod',
    dd: '%d diwrnod',
    M: 'mis',
    MM: '%d mis',
    y: 'blwyddyn',
    yy: '%d flynedd'
},
dayOfMonthOrdinalParse: /\d{1,2}(fed|ain|af|il|ydd|ed|eg)/,
// traditional ordinal numbers above 31 are not commonly used in colloquial Welsh
ordinal: function (number) {
    var b = number,
        output = '',
        lookup = [
            '', 'af', 'il', 'ydd', 'ydd', 'ed', 'ed', 'ed', 'fed', 'fed', 'fed', // 1af to 10fed
            'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'fed' // 11eg to 20fed
        ];
    if (b > 20) {
        if (b === 40 || b === 50 || b === 60 || b === 80 || b === 100) {
            output = 'fed'; // not 30ain, 70ain or 90ain
        } else {
            output = 'ain';
        }
    } else if (b > 0) {
        output = lookup[b];
    }
    return number + output;
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return cy;

})));

/***/ }), /* 58 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Danish [da] //! author : Ulrik Nielsen : github.com/mrbase

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var da = moment.defineLocale('da', {

months : 'januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december'.split('_'),
monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
weekdaysShort : 'søn_man_tir_ons_tor_fre_lør'.split('_'),
weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D. MMMM YYYY',
    LLL : 'D. MMMM YYYY HH:mm',
    LLLL : 'dddd [d.] D. MMMM YYYY [kl.] HH:mm'
},
calendar : {
    sameDay : '[i dag kl.] LT',
    nextDay : '[i morgen kl.] LT',
    nextWeek : 'på dddd [kl.] LT',
    lastDay : '[i går kl.] LT',
    lastWeek : '[i] dddd[s kl.] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'om %s',
    past : '%s siden',
    s : 'få sekunder',
    m : 'et minut',
    mm : '%d minutter',
    h : 'en time',
    hh : '%d timer',
    d : 'en dag',
    dd : '%d dage',
    M : 'en måned',
    MM : '%d måneder',
    y : 'et år',
    yy : '%d år'
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return da;

})));

/***/ }), /* 59 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : German [de] //! author : lluchs : github.com/lluchs //! author: Menelion Elensúle: github.com/Oire //! author : Mikolaj Dadela : github.com/mik01aj

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function processRelativeTime(number, withoutSuffix, key, isFuture) {

var format = {
    'm': ['eine Minute', 'einer Minute'],
    'h': ['eine Stunde', 'einer Stunde'],
    'd': ['ein Tag', 'einem Tag'],
    'dd': [number + ' Tage', number + ' Tagen'],
    'M': ['ein Monat', 'einem Monat'],
    'MM': [number + ' Monate', number + ' Monaten'],
    'y': ['ein Jahr', 'einem Jahr'],
    'yy': [number + ' Jahre', number + ' Jahren']
};
return withoutSuffix ? format[key][0] : format[key][1];

}

var de = moment.defineLocale('de', {

months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
monthsShort : 'Jan._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
monthsParseExact : true,
weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT: 'HH:mm',
    LTS: 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D. MMMM YYYY',
    LLL : 'D. MMMM YYYY HH:mm',
    LLLL : 'dddd, D. MMMM YYYY HH:mm'
},
calendar : {
    sameDay: '[heute um] LT [Uhr]',
    sameElse: 'L',
    nextDay: '[morgen um] LT [Uhr]',
    nextWeek: 'dddd [um] LT [Uhr]',
    lastDay: '[gestern um] LT [Uhr]',
    lastWeek: '[letzten] dddd [um] LT [Uhr]'
},
relativeTime : {
    future : 'in %s',
    past : 'vor %s',
    s : 'ein paar Sekunden',
    m : processRelativeTime,
    mm : '%d Minuten',
    h : processRelativeTime,
    hh : '%d Stunden',
    d : processRelativeTime,
    dd : processRelativeTime,
    M : processRelativeTime,
    MM : processRelativeTime,
    y : processRelativeTime,
    yy : processRelativeTime
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return de;

})));

/***/ }), /* 60 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : German (Austria) [de-at] //! author : lluchs : github.com/lluchs //! author: Menelion Elensúle: github.com/Oire //! author : Martin Groller : github.com/MadMG //! author : Mikolaj Dadela : github.com/mik01aj

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function processRelativeTime(number, withoutSuffix, key, isFuture) {

var format = {
    'm': ['eine Minute', 'einer Minute'],
    'h': ['eine Stunde', 'einer Stunde'],
    'd': ['ein Tag', 'einem Tag'],
    'dd': [number + ' Tage', number + ' Tagen'],
    'M': ['ein Monat', 'einem Monat'],
    'MM': [number + ' Monate', number + ' Monaten'],
    'y': ['ein Jahr', 'einem Jahr'],
    'yy': [number + ' Jahre', number + ' Jahren']
};
return withoutSuffix ? format[key][0] : format[key][1];

}

var deAt = moment.defineLocale('de-at', {

months : 'Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
monthsShort : 'Jän._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
monthsParseExact : true,
weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT: 'HH:mm',
    LTS: 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D. MMMM YYYY',
    LLL : 'D. MMMM YYYY HH:mm',
    LLLL : 'dddd, D. MMMM YYYY HH:mm'
},
calendar : {
    sameDay: '[heute um] LT [Uhr]',
    sameElse: 'L',
    nextDay: '[morgen um] LT [Uhr]',
    nextWeek: 'dddd [um] LT [Uhr]',
    lastDay: '[gestern um] LT [Uhr]',
    lastWeek: '[letzten] dddd [um] LT [Uhr]'
},
relativeTime : {
    future : 'in %s',
    past : 'vor %s',
    s : 'ein paar Sekunden',
    m : processRelativeTime,
    mm : '%d Minuten',
    h : processRelativeTime,
    hh : '%d Stunden',
    d : processRelativeTime,
    dd : processRelativeTime,
    M : processRelativeTime,
    MM : processRelativeTime,
    y : processRelativeTime,
    yy : processRelativeTime
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return deAt;

})));

/***/ }), /* 61 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : German (Switzerland) [de-ch] //! author : sschueller : github.com/sschueller

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

// based on: www.bk.admin.ch/dokumentation/sprachen/04915/05016/index.html?lang=de#

function processRelativeTime(number, withoutSuffix, key, isFuture) {

var format = {
    'm': ['eine Minute', 'einer Minute'],
    'h': ['eine Stunde', 'einer Stunde'],
    'd': ['ein Tag', 'einem Tag'],
    'dd': [number + ' Tage', number + ' Tagen'],
    'M': ['ein Monat', 'einem Monat'],
    'MM': [number + ' Monate', number + ' Monaten'],
    'y': ['ein Jahr', 'einem Jahr'],
    'yy': [number + ' Jahre', number + ' Jahren']
};
return withoutSuffix ? format[key][0] : format[key][1];

}

var deCh = moment.defineLocale('de-ch', {

months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
monthsShort : 'Jan._Febr._März_April_Mai_Juni_Juli_Aug._Sept._Okt._Nov._Dez.'.split('_'),
monthsParseExact : true,
weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
weekdaysShort : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT: 'HH.mm',
    LTS: 'HH.mm.ss',
    L : 'DD.MM.YYYY',
    LL : 'D. MMMM YYYY',
    LLL : 'D. MMMM YYYY HH.mm',
    LLLL : 'dddd, D. MMMM YYYY HH.mm'
},
calendar : {
    sameDay: '[heute um] LT [Uhr]',
    sameElse: 'L',
    nextDay: '[morgen um] LT [Uhr]',
    nextWeek: 'dddd [um] LT [Uhr]',
    lastDay: '[gestern um] LT [Uhr]',
    lastWeek: '[letzten] dddd [um] LT [Uhr]'
},
relativeTime : {
    future : 'in %s',
    past : 'vor %s',
    s : 'ein paar Sekunden',
    m : processRelativeTime,
    mm : '%d Minuten',
    h : processRelativeTime,
    hh : '%d Stunden',
    d : processRelativeTime,
    dd : processRelativeTime,
    M : processRelativeTime,
    MM : processRelativeTime,
    y : processRelativeTime,
    yy : processRelativeTime
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return deCh;

})));

/***/ }), /* 62 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Maldivian [dv] //! author : Jawish Hameed : github.com/jawish

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var months = [

'ޖެނުއަރީ',
'ފެބްރުއަރީ',
'މާރިޗު',
'އޭޕްރީލު',
'މޭ',
'ޖޫން',
'ޖުލައި',
'އޯގަސްޓު',
'ސެޕްޓެމްބަރު',
'އޮކްޓޯބަރު',
'ނޮވެމްބަރު',
'ޑިސެމްބަރު'

]; var weekdays = [

'އާދިއްތަ',
'ހޯމަ',
'އަންގާރަ',
'ބުދަ',
'ބުރާސްފަތި',
'ހުކުރު',
'ހޮނިހިރު'

];

var dv = moment.defineLocale('dv', {

months : months,
monthsShort : months,
weekdays : weekdays,
weekdaysShort : weekdays,
weekdaysMin : 'އާދި_ހޯމަ_އަން_ބުދަ_ބުރާ_ހުކު_ހޮނި'.split('_'),
longDateFormat : {

    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'D/M/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
meridiemParse: /މކ|މފ/,
isPM : function (input) {
    return 'މފ' === input;
},
meridiem : function (hour, minute, isLower) {
    if (hour < 12) {
        return 'މކ';
    } else {
        return 'މފ';
    }
},
calendar : {
    sameDay : '[މިއަދު] LT',
    nextDay : '[މާދަމާ] LT',
    nextWeek : 'dddd LT',
    lastDay : '[އިއްޔެ] LT',
    lastWeek : '[ފާއިތުވި] dddd LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'ތެރޭގައި %s',
    past : 'ކުރިން %s',
    s : 'ސިކުންތުކޮޅެއް',
    m : 'މިނިޓެއް',
    mm : 'މިނިޓު %d',
    h : 'ގަޑިއިރެއް',
    hh : 'ގަޑިއިރު %d',
    d : 'ދުވަހެއް',
    dd : 'ދުވަސް %d',
    M : 'މަހެއް',
    MM : 'މަސް %d',
    y : 'އަހަރެއް',
    yy : 'އަހަރު %d'
},
preparse: function (string) {
    return string.replace(/،/g, ',');
},
postformat: function (string) {
    return string.replace(/,/g, '،');
},
week : {
    dow : 7,  // Sunday is the first day of the week.
    doy : 12  // The week that contains Jan 1st is the first week of the year.
}

});

return dv;

})));

/***/ }), /* 63 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Greek [el] //! author : Aggelos Karalias : github.com/mehiel

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function isFunction(input) {

return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';

}

var el = moment.defineLocale('el', {

monthsNominativeEl : 'Ιανουάριος_Φεβρουάριος_Μάρτιος_Απρίλιος_Μάιος_Ιούνιος_Ιούλιος_Αύγουστος_Σεπτέμβριος_Οκτώβριος_Νοέμβριος_Δεκέμβριος'.split('_'),
monthsGenitiveEl : 'Ιανουαρίου_Φεβρουαρίου_Μαρτίου_Απριλίου_Μαΐου_Ιουνίου_Ιουλίου_Αυγούστου_Σεπτεμβρίου_Οκτωβρίου_Νοεμβρίου_Δεκεμβρίου'.split('_'),
months : function (momentToFormat, format) {
    if (!momentToFormat) {
        return this._monthsNominativeEl;
    } else if (/D/.test(format.substring(0, format.indexOf('MMMM')))) { // if there is a day number before 'MMMM'
        return this._monthsGenitiveEl[momentToFormat.month()];
    } else {
        return this._monthsNominativeEl[momentToFormat.month()];
    }
},
monthsShort : 'Ιαν_Φεβ_Μαρ_Απρ_Μαϊ_Ιουν_Ιουλ_Αυγ_Σεπ_Οκτ_Νοε_Δεκ'.split('_'),
weekdays : 'Κυριακή_Δευτέρα_Τρίτη_Τετάρτη_Πέμπτη_Παρασκευή_Σάββατο'.split('_'),
weekdaysShort : 'Κυρ_Δευ_Τρι_Τετ_Πεμ_Παρ_Σαβ'.split('_'),
weekdaysMin : 'Κυ_Δε_Τρ_Τε_Πε_Πα_Σα'.split('_'),
meridiem : function (hours, minutes, isLower) {
    if (hours > 11) {
        return isLower ? 'μμ' : 'ΜΜ';
    } else {
        return isLower ? 'πμ' : 'ΠΜ';
    }
},
isPM : function (input) {
    return ((input + '').toLowerCase()[0] === 'μ');
},
meridiemParse : /[ΠΜ]\.?Μ?\.?/i,
longDateFormat : {
    LT : 'h:mm A',
    LTS : 'h:mm:ss A',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY h:mm A',
    LLLL : 'dddd, D MMMM YYYY h:mm A'
},
calendarEl : {
    sameDay : '[Σήμερα {}] LT',
    nextDay : '[Αύριο {}] LT',
    nextWeek : 'dddd [{}] LT',
    lastDay : '[Χθες {}] LT',
    lastWeek : function () {
        switch (this.day()) {
            case 6:
                return '[το προηγούμενο] dddd [{}] LT';
            default:
                return '[την προηγούμενη] dddd [{}] LT';
        }
    },
    sameElse : 'L'
},
calendar : function (key, mom) {
    var output = this._calendarEl[key],
        hours = mom && mom.hours();
    if (isFunction(output)) {
        output = output.apply(mom);
    }
    return output.replace('{}', (hours % 12 === 1 ? 'στη' : 'στις'));
},
relativeTime : {
    future : 'σε %s',
    past : '%s πριν',
    s : 'λίγα δευτερόλεπτα',
    m : 'ένα λεπτό',
    mm : '%d λεπτά',
    h : 'μία ώρα',
    hh : '%d ώρες',
    d : 'μία μέρα',
    dd : '%d μέρες',
    M : 'ένας μήνας',
    MM : '%d μήνες',
    y : 'ένας χρόνος',
    yy : '%d χρόνια'
},
dayOfMonthOrdinalParse: /\d{1,2}η/,
ordinal: '%dη',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4st is the first week of the year.
}

});

return el;

})));

/***/ }), /* 64 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : English (Australia) [en-au] //! author : Jared Morse : github.com/jarcoal

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var enAu = moment.defineLocale('en-au', {

months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
longDateFormat : {
    LT : 'h:mm A',
    LTS : 'h:mm:ss A',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY h:mm A',
    LLLL : 'dddd, D MMMM YYYY h:mm A'
},
calendar : {
    sameDay : '[Today at] LT',
    nextDay : '[Tomorrow at] LT',
    nextWeek : 'dddd [at] LT',
    lastDay : '[Yesterday at] LT',
    lastWeek : '[Last] dddd [at] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'in %s',
    past : '%s ago',
    s : 'a few seconds',
    m : 'a minute',
    mm : '%d minutes',
    h : 'an hour',
    hh : '%d hours',
    d : 'a day',
    dd : '%d days',
    M : 'a month',
    MM : '%d months',
    y : 'a year',
    yy : '%d years'
},
dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
ordinal : function (number) {
    var b = number % 10,
        output = (~~(number % 100 / 10) === 1) ? 'th' :
        (b === 1) ? 'st' :
        (b === 2) ? 'nd' :
        (b === 3) ? 'rd' : 'th';
    return number + output;
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return enAu;

})));

/***/ }), /* 65 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : English (Canada) [en-ca] //! author : Jonathan Abourbih : github.com/jonbca

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var enCa = moment.defineLocale('en-ca', {

months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
longDateFormat : {
    LT : 'h:mm A',
    LTS : 'h:mm:ss A',
    L : 'YYYY-MM-DD',
    LL : 'MMMM D, YYYY',
    LLL : 'MMMM D, YYYY h:mm A',
    LLLL : 'dddd, MMMM D, YYYY h:mm A'
},
calendar : {
    sameDay : '[Today at] LT',
    nextDay : '[Tomorrow at] LT',
    nextWeek : 'dddd [at] LT',
    lastDay : '[Yesterday at] LT',
    lastWeek : '[Last] dddd [at] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'in %s',
    past : '%s ago',
    s : 'a few seconds',
    m : 'a minute',
    mm : '%d minutes',
    h : 'an hour',
    hh : '%d hours',
    d : 'a day',
    dd : '%d days',
    M : 'a month',
    MM : '%d months',
    y : 'a year',
    yy : '%d years'
},
dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
ordinal : function (number) {
    var b = number % 10,
        output = (~~(number % 100 / 10) === 1) ? 'th' :
        (b === 1) ? 'st' :
        (b === 2) ? 'nd' :
        (b === 3) ? 'rd' : 'th';
    return number + output;
}

});

return enCa;

})));

/***/ }), /* 66 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : English (United Kingdom) [en-gb] //! author : Chris Gedrim : github.com/chrisgedrim

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var enGb = moment.defineLocale('en-gb', {

months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
calendar : {
    sameDay : '[Today at] LT',
    nextDay : '[Tomorrow at] LT',
    nextWeek : 'dddd [at] LT',
    lastDay : '[Yesterday at] LT',
    lastWeek : '[Last] dddd [at] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'in %s',
    past : '%s ago',
    s : 'a few seconds',
    m : 'a minute',
    mm : '%d minutes',
    h : 'an hour',
    hh : '%d hours',
    d : 'a day',
    dd : '%d days',
    M : 'a month',
    MM : '%d months',
    y : 'a year',
    yy : '%d years'
},
dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
ordinal : function (number) {
    var b = number % 10,
        output = (~~(number % 100 / 10) === 1) ? 'th' :
        (b === 1) ? 'st' :
        (b === 2) ? 'nd' :
        (b === 3) ? 'rd' : 'th';
    return number + output;
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return enGb;

})));

/***/ }), /* 67 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : English (Ireland) [en-ie] //! author : Chris Cartlidge : github.com/chriscartlidge

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var enIe = moment.defineLocale('en-ie', {

months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD-MM-YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
calendar : {
    sameDay : '[Today at] LT',
    nextDay : '[Tomorrow at] LT',
    nextWeek : 'dddd [at] LT',
    lastDay : '[Yesterday at] LT',
    lastWeek : '[Last] dddd [at] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'in %s',
    past : '%s ago',
    s : 'a few seconds',
    m : 'a minute',
    mm : '%d minutes',
    h : 'an hour',
    hh : '%d hours',
    d : 'a day',
    dd : '%d days',
    M : 'a month',
    MM : '%d months',
    y : 'a year',
    yy : '%d years'
},
dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
ordinal : function (number) {
    var b = number % 10,
        output = (~~(number % 100 / 10) === 1) ? 'th' :
        (b === 1) ? 'st' :
        (b === 2) ? 'nd' :
        (b === 3) ? 'rd' : 'th';
    return number + output;
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return enIe;

})));

/***/ }), /* 68 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : English (New Zealand) [en-nz] //! author : Luke McGregor : github.com/lukemcgregor

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var enNz = moment.defineLocale('en-nz', {

months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
longDateFormat : {
    LT : 'h:mm A',
    LTS : 'h:mm:ss A',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY h:mm A',
    LLLL : 'dddd, D MMMM YYYY h:mm A'
},
calendar : {
    sameDay : '[Today at] LT',
    nextDay : '[Tomorrow at] LT',
    nextWeek : 'dddd [at] LT',
    lastDay : '[Yesterday at] LT',
    lastWeek : '[Last] dddd [at] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'in %s',
    past : '%s ago',
    s : 'a few seconds',
    m : 'a minute',
    mm : '%d minutes',
    h : 'an hour',
    hh : '%d hours',
    d : 'a day',
    dd : '%d days',
    M : 'a month',
    MM : '%d months',
    y : 'a year',
    yy : '%d years'
},
dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
ordinal : function (number) {
    var b = number % 10,
        output = (~~(number % 100 / 10) === 1) ? 'th' :
        (b === 1) ? 'st' :
        (b === 2) ? 'nd' :
        (b === 3) ? 'rd' : 'th';
    return number + output;
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return enNz;

})));

/***/ }), /* 69 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Esperanto [eo] //! author : Colin Dean : github.com/colindean //! author : Mia Nordentoft Imperatori : github.com/miestasmia //! comment : miestasmia corrected the translation by colindean

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var eo = moment.defineLocale('eo', {

months : 'januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro'.split('_'),
monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aŭg_sep_okt_nov_dec'.split('_'),
weekdays : 'dimanĉo_lundo_mardo_merkredo_ĵaŭdo_vendredo_sabato'.split('_'),
weekdaysShort : 'dim_lun_mard_merk_ĵaŭ_ven_sab'.split('_'),
weekdaysMin : 'di_lu_ma_me_ĵa_ve_sa'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'YYYY-MM-DD',
    LL : 'D[-a de] MMMM, YYYY',
    LLL : 'D[-a de] MMMM, YYYY HH:mm',
    LLLL : 'dddd, [la] D[-a de] MMMM, YYYY HH:mm'
},
meridiemParse: /[ap]\.t\.m/i,
isPM: function (input) {
    return input.charAt(0).toLowerCase() === 'p';
},
meridiem : function (hours, minutes, isLower) {
    if (hours > 11) {
        return isLower ? 'p.t.m.' : 'P.T.M.';
    } else {
        return isLower ? 'a.t.m.' : 'A.T.M.';
    }
},
calendar : {
    sameDay : '[Hodiaŭ je] LT',
    nextDay : '[Morgaŭ je] LT',
    nextWeek : 'dddd [je] LT',
    lastDay : '[Hieraŭ je] LT',
    lastWeek : '[pasinta] dddd [je] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'post %s',
    past : 'antaŭ %s',
    s : 'sekundoj',
    m : 'minuto',
    mm : '%d minutoj',
    h : 'horo',
    hh : '%d horoj',
    d : 'tago',//ne 'diurno', ĉar estas uzita por proksimumo
    dd : '%d tagoj',
    M : 'monato',
    MM : '%d monatoj',
    y : 'jaro',
    yy : '%d jaroj'
},
dayOfMonthOrdinalParse: /\d{1,2}a/,
ordinal : '%da',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return eo;

})));

/***/ }), /* 70 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Spanish [es] //! author : Julio Napurí : github.com/julionc

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'); var monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');

var es = moment.defineLocale('es', {

months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
monthsShort : function (m, format) {
    if (!m) {
        return monthsShortDot;
    } else if (/-MMM-/.test(format)) {
        return monthsShort[m.month()];
    } else {
        return monthsShortDot[m.month()];
    }
},
monthsParseExact : true,
weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'H:mm',
    LTS : 'H:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D [de] MMMM [de] YYYY',
    LLL : 'D [de] MMMM [de] YYYY H:mm',
    LLLL : 'dddd, D [de] MMMM [de] YYYY H:mm'
},
calendar : {
    sameDay : function () {
        return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
    },
    nextDay : function () {
        return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
    },
    nextWeek : function () {
        return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
    },
    lastDay : function () {
        return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
    },
    lastWeek : function () {
        return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
    },
    sameElse : 'L'
},
relativeTime : {
    future : 'en %s',
    past : 'hace %s',
    s : 'unos segundos',
    m : 'un minuto',
    mm : '%d minutos',
    h : 'una hora',
    hh : '%d horas',
    d : 'un día',
    dd : '%d días',
    M : 'un mes',
    MM : '%d meses',
    y : 'un año',
    yy : '%d años'
},
dayOfMonthOrdinalParse : /\d{1,2}º/,
ordinal : '%dº',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return es;

})));

/***/ }), /* 71 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Spanish (Dominican Republic) [es-do]

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'); var monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');

var esDo = moment.defineLocale('es-do', {

months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
monthsShort : function (m, format) {
    if (!m) {
        return monthsShortDot;
    } else if (/-MMM-/.test(format)) {
        return monthsShort[m.month()];
    } else {
        return monthsShortDot[m.month()];
    }
},
monthsParseExact : true,
weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'h:mm A',
    LTS : 'h:mm:ss A',
    L : 'DD/MM/YYYY',
    LL : 'D [de] MMMM [de] YYYY',
    LLL : 'D [de] MMMM [de] YYYY h:mm A',
    LLLL : 'dddd, D [de] MMMM [de] YYYY h:mm A'
},
calendar : {
    sameDay : function () {
        return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
    },
    nextDay : function () {
        return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
    },
    nextWeek : function () {
        return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
    },
    lastDay : function () {
        return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
    },
    lastWeek : function () {
        return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
    },
    sameElse : 'L'
},
relativeTime : {
    future : 'en %s',
    past : 'hace %s',
    s : 'unos segundos',
    m : 'un minuto',
    mm : '%d minutos',
    h : 'una hora',
    hh : '%d horas',
    d : 'un día',
    dd : '%d días',
    M : 'un mes',
    MM : '%d meses',
    y : 'un año',
    yy : '%d años'
},
dayOfMonthOrdinalParse : /\d{1,2}º/,
ordinal : '%dº',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return esDo;

})));

/***/ }), /* 72 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Estonian [et] //! author : Henry Kehlmann : github.com/madhenry //! improvements : Illimar Tambek : github.com/ragulka

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function processRelativeTime(number, withoutSuffix, key, isFuture) {

var format = {
    's' : ['mõne sekundi', 'mõni sekund', 'paar sekundit'],
    'm' : ['ühe minuti', 'üks minut'],
    'mm': [number + ' minuti', number + ' minutit'],
    'h' : ['ühe tunni', 'tund aega', 'üks tund'],
    'hh': [number + ' tunni', number + ' tundi'],
    'd' : ['ühe päeva', 'üks päev'],
    'M' : ['kuu aja', 'kuu aega', 'üks kuu'],
    'MM': [number + ' kuu', number + ' kuud'],
    'y' : ['ühe aasta', 'aasta', 'üks aasta'],
    'yy': [number + ' aasta', number + ' aastat']
};
if (withoutSuffix) {
    return format[key][2] ? format[key][2] : format[key][1];
}
return isFuture ? format[key][0] : format[key][1];

}

var et = moment.defineLocale('et', {

months        : 'jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember'.split('_'),
monthsShort   : 'jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets'.split('_'),
weekdays      : 'pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev'.split('_'),
weekdaysShort : 'P_E_T_K_N_R_L'.split('_'),
weekdaysMin   : 'P_E_T_K_N_R_L'.split('_'),
longDateFormat : {
    LT   : 'H:mm',
    LTS : 'H:mm:ss',
    L    : 'DD.MM.YYYY',
    LL   : 'D. MMMM YYYY',
    LLL  : 'D. MMMM YYYY H:mm',
    LLLL : 'dddd, D. MMMM YYYY H:mm'
},
calendar : {
    sameDay  : '[Täna,] LT',
    nextDay  : '[Homme,] LT',
    nextWeek : '[Järgmine] dddd LT',
    lastDay  : '[Eile,] LT',
    lastWeek : '[Eelmine] dddd LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s pärast',
    past   : '%s tagasi',
    s      : processRelativeTime,
    m      : processRelativeTime,
    mm     : processRelativeTime,
    h      : processRelativeTime,
    hh     : processRelativeTime,
    d      : processRelativeTime,
    dd     : '%d päeva',
    M      : processRelativeTime,
    MM     : processRelativeTime,
    y      : processRelativeTime,
    yy     : processRelativeTime
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return et;

})));

/***/ }), /* 73 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Basque [eu] //! author : Eneko Illarramendi : github.com/eillarra

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var eu = moment.defineLocale('eu', {

months : 'urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua'.split('_'),
monthsShort : 'urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.'.split('_'),
monthsParseExact : true,
weekdays : 'igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata'.split('_'),
weekdaysShort : 'ig._al._ar._az._og._ol._lr.'.split('_'),
weekdaysMin : 'ig_al_ar_az_og_ol_lr'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'YYYY-MM-DD',
    LL : 'YYYY[ko] MMMM[ren] D[a]',
    LLL : 'YYYY[ko] MMMM[ren] D[a] HH:mm',
    LLLL : 'dddd, YYYY[ko] MMMM[ren] D[a] HH:mm',
    l : 'YYYY-M-D',
    ll : 'YYYY[ko] MMM D[a]',
    lll : 'YYYY[ko] MMM D[a] HH:mm',
    llll : 'ddd, YYYY[ko] MMM D[a] HH:mm'
},
calendar : {
    sameDay : '[gaur] LT[etan]',
    nextDay : '[bihar] LT[etan]',
    nextWeek : 'dddd LT[etan]',
    lastDay : '[atzo] LT[etan]',
    lastWeek : '[aurreko] dddd LT[etan]',
    sameElse : 'L'
},
relativeTime : {
    future : '%s barru',
    past : 'duela %s',
    s : 'segundo batzuk',
    m : 'minutu bat',
    mm : '%d minutu',
    h : 'ordu bat',
    hh : '%d ordu',
    d : 'egun bat',
    dd : '%d egun',
    M : 'hilabete bat',
    MM : '%d hilabete',
    y : 'urte bat',
    yy : '%d urte'
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return eu;

})));

/***/ }), /* 74 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Persian [fa] //! author : Ebrahim Byagowi : github.com/ebraminio

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var symbolMap = {

'1': '۱',
'2': '۲',
'3': '۳',
'4': '۴',
'5': '۵',
'6': '۶',
'7': '۷',
'8': '۸',
'9': '۹',
'0': '۰'

}; var numberMap = {

'۱': '1',
'۲': '2',
'۳': '3',
'۴': '4',
'۵': '5',
'۶': '6',
'۷': '7',
'۸': '8',
'۹': '9',
'۰': '0'

};

var fa = moment.defineLocale('fa', {

months : 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
monthsShort : 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
weekdays : 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
weekdaysShort : 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
weekdaysMin : 'ی_د_س_چ_پ_ج_ش'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
meridiemParse: /قبل از ظهر|بعد از ظهر/,
isPM: function (input) {
    return /بعد از ظهر/.test(input);
},
meridiem : function (hour, minute, isLower) {
    if (hour < 12) {
        return 'قبل از ظهر';
    } else {
        return 'بعد از ظهر';
    }
},
calendar : {
    sameDay : '[امروز ساعت] LT',
    nextDay : '[فردا ساعت] LT',
    nextWeek : 'dddd [ساعت] LT',
    lastDay : '[دیروز ساعت] LT',
    lastWeek : 'dddd [پیش] [ساعت] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'در %s',
    past : '%s پیش',
    s : 'چند ثانیه',
    m : 'یک دقیقه',
    mm : '%d دقیقه',
    h : 'یک ساعت',
    hh : '%d ساعت',
    d : 'یک روز',
    dd : '%d روز',
    M : 'یک ماه',
    MM : '%d ماه',
    y : 'یک سال',
    yy : '%d سال'
},
preparse: function (string) {
    return string.replace(/[۰-۹]/g, function (match) {
        return numberMap[match];
    }).replace(/،/g, ',');
},
postformat: function (string) {
    return string.replace(/\d/g, function (match) {
        return symbolMap[match];
    }).replace(/,/g, '،');
},
dayOfMonthOrdinalParse: /\d{1,2}م/,
ordinal : '%dم',
week : {
    dow : 6, // Saturday is the first day of the week.
    doy : 12 // The week that contains Jan 1st is the first week of the year.
}

});

return fa;

})));

/***/ }), /* 75 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Finnish [fi] //! author : Tarmo Aidantausta : github.com/bleadof

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var numbersPast = 'nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän'.split(' '); var numbersFuture = [

    'nolla', 'yhden', 'kahden', 'kolmen', 'neljän', 'viiden', 'kuuden',
    numbersPast[7], numbersPast[8], numbersPast[9]
];

function translate(number, withoutSuffix, key, isFuture) {

var result = '';
switch (key) {
    case 's':
        return isFuture ? 'muutaman sekunnin' : 'muutama sekunti';
    case 'm':
        return isFuture ? 'minuutin' : 'minuutti';
    case 'mm':
        result = isFuture ? 'minuutin' : 'minuuttia';
        break;
    case 'h':
        return isFuture ? 'tunnin' : 'tunti';
    case 'hh':
        result = isFuture ? 'tunnin' : 'tuntia';
        break;
    case 'd':
        return isFuture ? 'päivän' : 'päivä';
    case 'dd':
        result = isFuture ? 'päivän' : 'päivää';
        break;
    case 'M':
        return isFuture ? 'kuukauden' : 'kuukausi';
    case 'MM':
        result = isFuture ? 'kuukauden' : 'kuukautta';
        break;
    case 'y':
        return isFuture ? 'vuoden' : 'vuosi';
    case 'yy':
        result = isFuture ? 'vuoden' : 'vuotta';
        break;
}
result = verbalNumber(number, isFuture) + ' ' + result;
return result;

} function verbalNumber(number, isFuture) {

return number < 10 ? (isFuture ? numbersFuture[number] : numbersPast[number]) : number;

}

var fi = moment.defineLocale('fi', {

months : 'tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu'.split('_'),
monthsShort : 'tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu'.split('_'),
weekdays : 'sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai'.split('_'),
weekdaysShort : 'su_ma_ti_ke_to_pe_la'.split('_'),
weekdaysMin : 'su_ma_ti_ke_to_pe_la'.split('_'),
longDateFormat : {
    LT : 'HH.mm',
    LTS : 'HH.mm.ss',
    L : 'DD.MM.YYYY',
    LL : 'Do MMMM[ta] YYYY',
    LLL : 'Do MMMM[ta] YYYY, [klo] HH.mm',
    LLLL : 'dddd, Do MMMM[ta] YYYY, [klo] HH.mm',
    l : 'D.M.YYYY',
    ll : 'Do MMM YYYY',
    lll : 'Do MMM YYYY, [klo] HH.mm',
    llll : 'ddd, Do MMM YYYY, [klo] HH.mm'
},
calendar : {
    sameDay : '[tänään] [klo] LT',
    nextDay : '[huomenna] [klo] LT',
    nextWeek : 'dddd [klo] LT',
    lastDay : '[eilen] [klo] LT',
    lastWeek : '[viime] dddd[na] [klo] LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s päästä',
    past : '%s sitten',
    s : translate,
    m : translate,
    mm : translate,
    h : translate,
    hh : translate,
    d : translate,
    dd : translate,
    M : translate,
    MM : translate,
    y : translate,
    yy : translate
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return fi;

})));

/***/ }), /* 76 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Faroese [fo] //! author : Ragnar Johannesen : github.com/ragnar123

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var fo = moment.defineLocale('fo', {

months : 'januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
weekdays : 'sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur'.split('_'),
weekdaysShort : 'sun_mán_týs_mik_hós_frí_ley'.split('_'),
weekdaysMin : 'su_má_tý_mi_hó_fr_le'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D. MMMM, YYYY HH:mm'
},
calendar : {
    sameDay : '[Í dag kl.] LT',
    nextDay : '[Í morgin kl.] LT',
    nextWeek : 'dddd [kl.] LT',
    lastDay : '[Í gjár kl.] LT',
    lastWeek : '[síðstu] dddd [kl] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'um %s',
    past : '%s síðani',
    s : 'fá sekund',
    m : 'ein minutt',
    mm : '%d minuttir',
    h : 'ein tími',
    hh : '%d tímar',
    d : 'ein dagur',
    dd : '%d dagar',
    M : 'ein mánaði',
    MM : '%d mánaðir',
    y : 'eitt ár',
    yy : '%d ár'
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return fo;

})));

/***/ }), /* 77 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : French [fr] //! author : John Fischer : github.com/jfroffice

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var fr = moment.defineLocale('fr', {

months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
monthsParseExact : true,
weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
calendar : {
    sameDay : '[Aujourd’hui à] LT',
    nextDay : '[Demain à] LT',
    nextWeek : 'dddd [à] LT',
    lastDay : '[Hier à] LT',
    lastWeek : 'dddd [dernier à] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'dans %s',
    past : 'il y a %s',
    s : 'quelques secondes',
    m : 'une minute',
    mm : '%d minutes',
    h : 'une heure',
    hh : '%d heures',
    d : 'un jour',
    dd : '%d jours',
    M : 'un mois',
    MM : '%d mois',
    y : 'un an',
    yy : '%d ans'
},
dayOfMonthOrdinalParse: /\d{1,2}(er|)/,
ordinal : function (number, period) {
    switch (period) {
        // TODO: Return 'e' when day of month > 1. Move this case inside
        // block for masculine words below.
        // See https://github.com/moment/moment/issues/3375
        case 'D':
            return number + (number === 1 ? 'er' : '');

        // Words with masculine grammatical gender: mois, trimestre, jour
        default:
        case 'M':
        case 'Q':
        case 'DDD':
        case 'd':
            return number + (number === 1 ? 'er' : 'e');

        // Words with feminine grammatical gender: semaine
        case 'w':
        case 'W':
            return number + (number === 1 ? 're' : 'e');
    }
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return fr;

})));

/***/ }), /* 78 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : French (Canada) [fr-ca] //! author : Jonathan Abourbih : github.com/jonbca

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var frCa = moment.defineLocale('fr-ca', {

months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
monthsParseExact : true,
weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'YYYY-MM-DD',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
calendar : {
    sameDay : '[Aujourd’hui à] LT',
    nextDay : '[Demain à] LT',
    nextWeek : 'dddd [à] LT',
    lastDay : '[Hier à] LT',
    lastWeek : 'dddd [dernier à] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'dans %s',
    past : 'il y a %s',
    s : 'quelques secondes',
    m : 'une minute',
    mm : '%d minutes',
    h : 'une heure',
    hh : '%d heures',
    d : 'un jour',
    dd : '%d jours',
    M : 'un mois',
    MM : '%d mois',
    y : 'un an',
    yy : '%d ans'
},
dayOfMonthOrdinalParse: /\d{1,2}(er|e)/,
ordinal : function (number, period) {
    switch (period) {
        // Words with masculine grammatical gender: mois, trimestre, jour
        default:
        case 'M':
        case 'Q':
        case 'D':
        case 'DDD':
        case 'd':
            return number + (number === 1 ? 'er' : 'e');

        // Words with feminine grammatical gender: semaine
        case 'w':
        case 'W':
            return number + (number === 1 ? 're' : 'e');
    }
}

});

return frCa;

})));

/***/ }), /* 79 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : French (Switzerland) [fr-ch] //! author : Gaspard Bucher : github.com/gaspard

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var frCh = moment.defineLocale('fr-ch', {

months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
monthsParseExact : true,
weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
calendar : {
    sameDay : '[Aujourd’hui à] LT',
    nextDay : '[Demain à] LT',
    nextWeek : 'dddd [à] LT',
    lastDay : '[Hier à] LT',
    lastWeek : 'dddd [dernier à] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'dans %s',
    past : 'il y a %s',
    s : 'quelques secondes',
    m : 'une minute',
    mm : '%d minutes',
    h : 'une heure',
    hh : '%d heures',
    d : 'un jour',
    dd : '%d jours',
    M : 'un mois',
    MM : '%d mois',
    y : 'un an',
    yy : '%d ans'
},
dayOfMonthOrdinalParse: /\d{1,2}(er|e)/,
ordinal : function (number, period) {
    switch (period) {
        // Words with masculine grammatical gender: mois, trimestre, jour
        default:
        case 'M':
        case 'Q':
        case 'D':
        case 'DDD':
        case 'd':
            return number + (number === 1 ? 'er' : 'e');

        // Words with feminine grammatical gender: semaine
        case 'w':
        case 'W':
            return number + (number === 1 ? 're' : 'e');
    }
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return frCh;

})));

/***/ }), /* 80 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Frisian [fy] //! author : Robin van der Vliet : github.com/robin0van0der0v

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var monthsShortWithDots = 'jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.'.split('_'); var monthsShortWithoutDots = 'jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_');

var fy = moment.defineLocale('fy', {

months : 'jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber'.split('_'),
monthsShort : function (m, format) {
    if (!m) {
        return monthsShortWithDots;
    } else if (/-MMM-/.test(format)) {
        return monthsShortWithoutDots[m.month()];
    } else {
        return monthsShortWithDots[m.month()];
    }
},
monthsParseExact : true,
weekdays : 'snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon'.split('_'),
weekdaysShort : 'si._mo._ti._wo._to._fr._so.'.split('_'),
weekdaysMin : 'Si_Mo_Ti_Wo_To_Fr_So'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD-MM-YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
calendar : {
    sameDay: '[hjoed om] LT',
    nextDay: '[moarn om] LT',
    nextWeek: 'dddd [om] LT',
    lastDay: '[juster om] LT',
    lastWeek: '[ôfrûne] dddd [om] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'oer %s',
    past : '%s lyn',
    s : 'in pear sekonden',
    m : 'ien minút',
    mm : '%d minuten',
    h : 'ien oere',
    hh : '%d oeren',
    d : 'ien dei',
    dd : '%d dagen',
    M : 'ien moanne',
    MM : '%d moannen',
    y : 'ien jier',
    yy : '%d jierren'
},
dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
ordinal : function (number) {
    return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return fy;

})));

/***/ }), /* 81 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Scottish Gaelic [gd] //! author : Jon Ashdown : github.com/jonashdown

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var months = [

'Am Faoilleach', 'An Gearran', 'Am Màrt', 'An Giblean', 'An Cèitean', 'An t-Ògmhios', 'An t-Iuchar', 'An Lùnastal', 'An t-Sultain', 'An Dàmhair', 'An t-Samhain', 'An Dùbhlachd'

];

var monthsShort = ['Faoi', 'Gear', 'Màrt', 'Gibl', 'Cèit', 'Ògmh', 'Iuch', 'Lùn', 'Sult', 'Dàmh', 'Samh', 'Dùbh'];

var weekdays = ['Didòmhnaich', 'Diluain', 'Dimàirt', 'Diciadain', 'Diardaoin', 'Dihaoine', 'Disathairne'];

var weekdaysShort = ['Did', 'Dil', 'Dim', 'Dic', 'Dia', 'Dih', 'Dis'];

var weekdaysMin = ['Dò', 'Lu', 'Mà', 'Ci', 'Ar', 'Ha', 'Sa'];

var gd = moment.defineLocale('gd', {

months : months,
monthsShort : monthsShort,
monthsParseExact : true,
weekdays : weekdays,
weekdaysShort : weekdaysShort,
weekdaysMin : weekdaysMin,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
calendar : {
    sameDay : '[An-diugh aig] LT',
    nextDay : '[A-màireach aig] LT',
    nextWeek : 'dddd [aig] LT',
    lastDay : '[An-dè aig] LT',
    lastWeek : 'dddd [seo chaidh] [aig] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'ann an %s',
    past : 'bho chionn %s',
    s : 'beagan diogan',
    m : 'mionaid',
    mm : '%d mionaidean',
    h : 'uair',
    hh : '%d uairean',
    d : 'latha',
    dd : '%d latha',
    M : 'mìos',
    MM : '%d mìosan',
    y : 'bliadhna',
    yy : '%d bliadhna'
},
dayOfMonthOrdinalParse : /\d{1,2}(d|na|mh)/,
ordinal : function (number) {
    var output = number === 1 ? 'd' : number % 10 === 2 ? 'na' : 'mh';
    return number + output;
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return gd;

})));

/***/ }), /* 82 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Galician [gl] //! author : Juan G. Hurtado : github.com/juanghurtado

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var gl = moment.defineLocale('gl', {

months : 'xaneiro_febreiro_marzo_abril_maio_xuño_xullo_agosto_setembro_outubro_novembro_decembro'.split('_'),
monthsShort : 'xan._feb._mar._abr._mai._xuñ._xul._ago._set._out._nov._dec.'.split('_'),
monthsParseExact: true,
weekdays : 'domingo_luns_martes_mércores_xoves_venres_sábado'.split('_'),
weekdaysShort : 'dom._lun._mar._mér._xov._ven._sáb.'.split('_'),
weekdaysMin : 'do_lu_ma_mé_xo_ve_sá'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'H:mm',
    LTS : 'H:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D [de] MMMM [de] YYYY',
    LLL : 'D [de] MMMM [de] YYYY H:mm',
    LLLL : 'dddd, D [de] MMMM [de] YYYY H:mm'
},
calendar : {
    sameDay : function () {
        return '[hoxe ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
    },
    nextDay : function () {
        return '[mañá ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
    },
    nextWeek : function () {
        return 'dddd [' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
    },
    lastDay : function () {
        return '[onte ' + ((this.hours() !== 1) ? 'á' : 'a') + '] LT';
    },
    lastWeek : function () {
        return '[o] dddd [pasado ' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
    },
    sameElse : 'L'
},
relativeTime : {
    future : function (str) {
        if (str.indexOf('un') === 0) {
            return 'n' + str;
        }
        return 'en ' + str;
    },
    past : 'hai %s',
    s : 'uns segundos',
    m : 'un minuto',
    mm : '%d minutos',
    h : 'unha hora',
    hh : '%d horas',
    d : 'un día',
    dd : '%d días',
    M : 'un mes',
    MM : '%d meses',
    y : 'un ano',
    yy : '%d anos'
},
dayOfMonthOrdinalParse : /\d{1,2}º/,
ordinal : '%dº',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return gl;

})));

/***/ }), /* 83 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Konkani Latin script [gom-latn] //! author : The Discoverer : github.com/WikiDiscoverer

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function processRelativeTime(number, withoutSuffix, key, isFuture) {

var format = {
    's': ['thodde secondanim', 'thodde second'],
    'm': ['eka mintan', 'ek minute'],
    'mm': [number + ' mintanim', number + ' mintam'],
    'h': ['eka horan', 'ek hor'],
    'hh': [number + ' horanim', number + ' hor'],
    'd': ['eka disan', 'ek dis'],
    'dd': [number + ' disanim', number + ' dis'],
    'M': ['eka mhoinean', 'ek mhoino'],
    'MM': [number + ' mhoineanim', number + ' mhoine'],
    'y': ['eka vorsan', 'ek voros'],
    'yy': [number + ' vorsanim', number + ' vorsam']
};
return withoutSuffix ? format[key][0] : format[key][1];

}

var gomLatn = moment.defineLocale('gom-latn', {

months : 'Janer_Febrer_Mars_Abril_Mai_Jun_Julai_Agost_Setembr_Otubr_Novembr_Dezembr'.split('_'),
monthsShort : 'Jan._Feb._Mars_Abr._Mai_Jun_Jul._Ago._Set._Otu._Nov._Dez.'.split('_'),
monthsParseExact : true,
weekdays : 'Aitar_Somar_Mongllar_Budvar_Brestar_Sukrar_Son\'var'.split('_'),
weekdaysShort : 'Ait._Som._Mon._Bud._Bre._Suk._Son.'.split('_'),
weekdaysMin : 'Ai_Sm_Mo_Bu_Br_Su_Sn'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'A h:mm [vazta]',
    LTS : 'A h:mm:ss [vazta]',
    L : 'DD-MM-YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY A h:mm [vazta]',
    LLLL : 'dddd, MMMM[achea] Do, YYYY, A h:mm [vazta]',
    llll: 'ddd, D MMM YYYY, A h:mm [vazta]'
},
calendar : {
    sameDay: '[Aiz] LT',
    nextDay: '[Faleam] LT',
    nextWeek: '[Ieta to] dddd[,] LT',
    lastDay: '[Kal] LT',
    lastWeek: '[Fatlo] dddd[,] LT',
    sameElse: 'L'
},
relativeTime : {
    future : '%s',
    past : '%s adim',
    s : processRelativeTime,
    m : processRelativeTime,
    mm : processRelativeTime,
    h : processRelativeTime,
    hh : processRelativeTime,
    d : processRelativeTime,
    dd : processRelativeTime,
    M : processRelativeTime,
    MM : processRelativeTime,
    y : processRelativeTime,
    yy : processRelativeTime
},
dayOfMonthOrdinalParse : /\d{1,2}(er)/,
ordinal : function (number, period) {
    switch (period) {
        // the ordinal 'er' only applies to day of the month
        case 'D':
            return number + 'er';
        default:
        case 'M':
        case 'Q':
        case 'DDD':
        case 'd':
        case 'w':
        case 'W':
            return number;
    }
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
},
meridiemParse: /rati|sokalli|donparam|sanje/,
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === 'rati') {
        return hour < 4 ? hour : hour + 12;
    } else if (meridiem === 'sokalli') {
        return hour;
    } else if (meridiem === 'donparam') {
        return hour > 12 ? hour : hour + 12;
    } else if (meridiem === 'sanje') {
        return hour + 12;
    }
},
meridiem : function (hour, minute, isLower) {
    if (hour < 4) {
        return 'rati';
    } else if (hour < 12) {
        return 'sokalli';
    } else if (hour < 16) {
        return 'donparam';
    } else if (hour < 20) {
        return 'sanje';
    } else {
        return 'rati';
    }
}

});

return gomLatn;

})));

/***/ }), /* 84 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Hebrew [he] //! author : Tomer Cohen : github.com/tomer //! author : Moshe Simantov : github.com/DevelopmentIL //! author : Tal Ater : github.com/TalAter

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var he = moment.defineLocale('he', {

months : 'ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר'.split('_'),
monthsShort : 'ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳'.split('_'),
weekdays : 'ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת'.split('_'),
weekdaysShort : 'א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳'.split('_'),
weekdaysMin : 'א_ב_ג_ד_ה_ו_ש'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D [ב]MMMM YYYY',
    LLL : 'D [ב]MMMM YYYY HH:mm',
    LLLL : 'dddd, D [ב]MMMM YYYY HH:mm',
    l : 'D/M/YYYY',
    ll : 'D MMM YYYY',
    lll : 'D MMM YYYY HH:mm',
    llll : 'ddd, D MMM YYYY HH:mm'
},
calendar : {
    sameDay : '[היום ב־]LT',
    nextDay : '[מחר ב־]LT',
    nextWeek : 'dddd [בשעה] LT',
    lastDay : '[אתמול ב־]LT',
    lastWeek : '[ביום] dddd [האחרון בשעה] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'בעוד %s',
    past : 'לפני %s',
    s : 'מספר שניות',
    m : 'דקה',
    mm : '%d דקות',
    h : 'שעה',
    hh : function (number) {
        if (number === 2) {
            return 'שעתיים';
        }
        return number + ' שעות';
    },
    d : 'יום',
    dd : function (number) {
        if (number === 2) {
            return 'יומיים';
        }
        return number + ' ימים';
    },
    M : 'חודש',
    MM : function (number) {
        if (number === 2) {
            return 'חודשיים';
        }
        return number + ' חודשים';
    },
    y : 'שנה',
    yy : function (number) {
        if (number === 2) {
            return 'שנתיים';
        } else if (number % 10 === 0 && number !== 10) {
            return number + ' שנה';
        }
        return number + ' שנים';
    }
},
meridiemParse: /אחה"צ|לפנה"צ|אחרי הצהריים|לפני הצהריים|לפנות בוקר|בבוקר|בערב/i,
isPM : function (input) {
    return /^(אחה"צ|אחרי הצהריים|בערב)$/.test(input);
},
meridiem : function (hour, minute, isLower) {
    if (hour < 5) {
        return 'לפנות בוקר';
    } else if (hour < 10) {
        return 'בבוקר';
    } else if (hour < 12) {
        return isLower ? 'לפנה"צ' : 'לפני הצהריים';
    } else if (hour < 18) {
        return isLower ? 'אחה"צ' : 'אחרי הצהריים';
    } else {
        return 'בערב';
    }
}

});

return he;

})));

/***/ }), /* 85 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Hindi [hi] //! author : Mayank Singhal : github.com/mayanksinghal

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var symbolMap = {

'1': '१',
'2': '२',
'3': '३',
'4': '४',
'5': '५',
'6': '६',
'7': '७',
'8': '८',
'9': '९',
'0': '०'

}; var numberMap = {

'१': '1',
'२': '2',
'३': '3',
'४': '4',
'५': '5',
'६': '6',
'७': '7',
'८': '8',
'९': '9',
'०': '0'

};

var hi = moment.defineLocale('hi', {

months : 'जनवरी_फ़रवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितम्बर_अक्टूबर_नवम्बर_दिसम्बर'.split('_'),
monthsShort : 'जन._फ़र._मार्च_अप्रै._मई_जून_जुल._अग._सित._अक्टू._नव._दिस.'.split('_'),
monthsParseExact: true,
weekdays : 'रविवार_सोमवार_मंगलवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
weekdaysShort : 'रवि_सोम_मंगल_बुध_गुरू_शुक्र_शनि'.split('_'),
weekdaysMin : 'र_सो_मं_बु_गु_शु_श'.split('_'),
longDateFormat : {
    LT : 'A h:mm बजे',
    LTS : 'A h:mm:ss बजे',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY, A h:mm बजे',
    LLLL : 'dddd, D MMMM YYYY, A h:mm बजे'
},
calendar : {
    sameDay : '[आज] LT',
    nextDay : '[कल] LT',
    nextWeek : 'dddd, LT',
    lastDay : '[कल] LT',
    lastWeek : '[पिछले] dddd, LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s में',
    past : '%s पहले',
    s : 'कुछ ही क्षण',
    m : 'एक मिनट',
    mm : '%d मिनट',
    h : 'एक घंटा',
    hh : '%d घंटे',
    d : 'एक दिन',
    dd : '%d दिन',
    M : 'एक महीने',
    MM : '%d महीने',
    y : 'एक वर्ष',
    yy : '%d वर्ष'
},
preparse: function (string) {
    return string.replace(/[१२३४५६७८९०]/g, function (match) {
        return numberMap[match];
    });
},
postformat: function (string) {
    return string.replace(/\d/g, function (match) {
        return symbolMap[match];
    });
},
// Hindi notation for meridiems are quite fuzzy in practice. While there exists
// a rigid notion of a 'Pahar' it is not used as rigidly in modern Hindi.
meridiemParse: /रात|सुबह|दोपहर|शाम/,
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === 'रात') {
        return hour < 4 ? hour : hour + 12;
    } else if (meridiem === 'सुबह') {
        return hour;
    } else if (meridiem === 'दोपहर') {
        return hour >= 10 ? hour : hour + 12;
    } else if (meridiem === 'शाम') {
        return hour + 12;
    }
},
meridiem : function (hour, minute, isLower) {
    if (hour < 4) {
        return 'रात';
    } else if (hour < 10) {
        return 'सुबह';
    } else if (hour < 17) {
        return 'दोपहर';
    } else if (hour < 20) {
        return 'शाम';
    } else {
        return 'रात';
    }
},
week : {
    dow : 0, // Sunday is the first day of the week.
    doy : 6  // The week that contains Jan 1st is the first week of the year.
}

});

return hi;

})));

/***/ }), /* 86 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Croatian [hr] //! author : Bojan Marković : github.com/bmarkovic

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function translate(number, withoutSuffix, key) {

var result = number + ' ';
switch (key) {
    case 'm':
        return withoutSuffix ? 'jedna minuta' : 'jedne minute';
    case 'mm':
        if (number === 1) {
            result += 'minuta';
        } else if (number === 2 || number === 3 || number === 4) {
            result += 'minute';
        } else {
            result += 'minuta';
        }
        return result;
    case 'h':
        return withoutSuffix ? 'jedan sat' : 'jednog sata';
    case 'hh':
        if (number === 1) {
            result += 'sat';
        } else if (number === 2 || number === 3 || number === 4) {
            result += 'sata';
        } else {
            result += 'sati';
        }
        return result;
    case 'dd':
        if (number === 1) {
            result += 'dan';
        } else {
            result += 'dana';
        }
        return result;
    case 'MM':
        if (number === 1) {
            result += 'mjesec';
        } else if (number === 2 || number === 3 || number === 4) {
            result += 'mjeseca';
        } else {
            result += 'mjeseci';
        }
        return result;
    case 'yy':
        if (number === 1) {
            result += 'godina';
        } else if (number === 2 || number === 3 || number === 4) {
            result += 'godine';
        } else {
            result += 'godina';
        }
        return result;
}

}

var hr = moment.defineLocale('hr', {

months : {
    format: 'siječnja_veljače_ožujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca'.split('_'),
    standalone: 'siječanj_veljača_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac'.split('_')
},
monthsShort : 'sij._velj._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.'.split('_'),
monthsParseExact: true,
weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
weekdaysShort : 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
weekdaysMin : 'ne_po_ut_sr_če_pe_su'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'H:mm',
    LTS : 'H:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D. MMMM YYYY',
    LLL : 'D. MMMM YYYY H:mm',
    LLLL : 'dddd, D. MMMM YYYY H:mm'
},
calendar : {
    sameDay  : '[danas u] LT',
    nextDay  : '[sutra u] LT',
    nextWeek : function () {
        switch (this.day()) {
            case 0:
                return '[u] [nedjelju] [u] LT';
            case 3:
                return '[u] [srijedu] [u] LT';
            case 6:
                return '[u] [subotu] [u] LT';
            case 1:
            case 2:
            case 4:
            case 5:
                return '[u] dddd [u] LT';
        }
    },
    lastDay  : '[jučer u] LT',
    lastWeek : function () {
        switch (this.day()) {
            case 0:
            case 3:
                return '[prošlu] dddd [u] LT';
            case 6:
                return '[prošle] [subote] [u] LT';
            case 1:
            case 2:
            case 4:
            case 5:
                return '[prošli] dddd [u] LT';
        }
    },
    sameElse : 'L'
},
relativeTime : {
    future : 'za %s',
    past   : 'prije %s',
    s      : 'par sekundi',
    m      : translate,
    mm     : translate,
    h      : translate,
    hh     : translate,
    d      : 'dan',
    dd     : translate,
    M      : 'mjesec',
    MM     : translate,
    y      : 'godinu',
    yy     : translate
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return hr;

})));

/***/ }), /* 87 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Hungarian [hu] //! author : Adam Brunner : github.com/adambrunner

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var weekEndings = 'vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton'.split(' '); function translate(number, withoutSuffix, key, isFuture) {

var num = number,
    suffix;
switch (key) {
    case 's':
        return (isFuture || withoutSuffix) ? 'néhány másodperc' : 'néhány másodperce';
    case 'm':
        return 'egy' + (isFuture || withoutSuffix ? ' perc' : ' perce');
    case 'mm':
        return num + (isFuture || withoutSuffix ? ' perc' : ' perce');
    case 'h':
        return 'egy' + (isFuture || withoutSuffix ? ' óra' : ' órája');
    case 'hh':
        return num + (isFuture || withoutSuffix ? ' óra' : ' órája');
    case 'd':
        return 'egy' + (isFuture || withoutSuffix ? ' nap' : ' napja');
    case 'dd':
        return num + (isFuture || withoutSuffix ? ' nap' : ' napja');
    case 'M':
        return 'egy' + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
    case 'MM':
        return num + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
    case 'y':
        return 'egy' + (isFuture || withoutSuffix ? ' év' : ' éve');
    case 'yy':
        return num + (isFuture || withoutSuffix ? ' év' : ' éve');
}
return '';

} function week(isFuture) {

return (isFuture ? '' : '[múlt] ') + '[' + weekEndings[this.day()] + '] LT[-kor]';

}

var hu = moment.defineLocale('hu', {

months : 'január_február_március_április_május_június_július_augusztus_szeptember_október_november_december'.split('_'),
monthsShort : 'jan_feb_márc_ápr_máj_jún_júl_aug_szept_okt_nov_dec'.split('_'),
weekdays : 'vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat'.split('_'),
weekdaysShort : 'vas_hét_kedd_sze_csüt_pén_szo'.split('_'),
weekdaysMin : 'v_h_k_sze_cs_p_szo'.split('_'),
longDateFormat : {
    LT : 'H:mm',
    LTS : 'H:mm:ss',
    L : 'YYYY.MM.DD.',
    LL : 'YYYY. MMMM D.',
    LLL : 'YYYY. MMMM D. H:mm',
    LLLL : 'YYYY. MMMM D., dddd H:mm'
},
meridiemParse: /de|du/i,
isPM: function (input) {
    return input.charAt(1).toLowerCase() === 'u';
},
meridiem : function (hours, minutes, isLower) {
    if (hours < 12) {
        return isLower === true ? 'de' : 'DE';
    } else {
        return isLower === true ? 'du' : 'DU';
    }
},
calendar : {
    sameDay : '[ma] LT[-kor]',
    nextDay : '[holnap] LT[-kor]',
    nextWeek : function () {
        return week.call(this, true);
    },
    lastDay : '[tegnap] LT[-kor]',
    lastWeek : function () {
        return week.call(this, false);
    },
    sameElse : 'L'
},
relativeTime : {
    future : '%s múlva',
    past : '%s',
    s : translate,
    m : translate,
    mm : translate,
    h : translate,
    hh : translate,
    d : translate,
    dd : translate,
    M : translate,
    MM : translate,
    y : translate,
    yy : translate
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return hu;

})));

/***/ }), /* 88 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Armenian [hy-am] //! author : Armendarabyan : github.com/armendarabyan

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var hyAm = moment.defineLocale('hy-am', {

months : {
    format: 'հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի'.split('_'),
    standalone: 'հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր'.split('_')
},
monthsShort : 'հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ'.split('_'),
weekdays : 'կիրակի_երկուշաբթի_երեքշաբթի_չորեքշաբթի_հինգշաբթի_ուրբաթ_շաբաթ'.split('_'),
weekdaysShort : 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
weekdaysMin : 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D MMMM YYYY թ.',
    LLL : 'D MMMM YYYY թ., HH:mm',
    LLLL : 'dddd, D MMMM YYYY թ., HH:mm'
},
calendar : {
    sameDay: '[այսօր] LT',
    nextDay: '[վաղը] LT',
    lastDay: '[երեկ] LT',
    nextWeek: function () {
        return 'dddd [օրը ժամը] LT';
    },
    lastWeek: function () {
        return '[անցած] dddd [օրը ժամը] LT';
    },
    sameElse: 'L'
},
relativeTime : {
    future : '%s հետո',
    past : '%s առաջ',
    s : 'մի քանի վայրկյան',
    m : 'րոպե',
    mm : '%d րոպե',
    h : 'ժամ',
    hh : '%d ժամ',
    d : 'օր',
    dd : '%d օր',
    M : 'ամիս',
    MM : '%d ամիս',
    y : 'տարի',
    yy : '%d տարի'
},
meridiemParse: /գիշերվա|առավոտվա|ցերեկվա|երեկոյան/,
isPM: function (input) {
    return /^(ցերեկվա|երեկոյան)$/.test(input);
},
meridiem : function (hour) {
    if (hour < 4) {
        return 'գիշերվա';
    } else if (hour < 12) {
        return 'առավոտվա';
    } else if (hour < 17) {
        return 'ցերեկվա';
    } else {
        return 'երեկոյան';
    }
},
dayOfMonthOrdinalParse: /\d{1,2}|\d{1,2}-(ին|րդ)/,
ordinal: function (number, period) {
    switch (period) {
        case 'DDD':
        case 'w':
        case 'W':
        case 'DDDo':
            if (number === 1) {
                return number + '-ին';
            }
            return number + '-րդ';
        default:
            return number;
    }
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return hyAm;

})));

/***/ }), /* 89 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Indonesian [id] //! author : Mohammad Satrio Utomo : github.com/tyok //! reference: id.wikisource.org/wiki/Pedoman_Umum_Ejaan_Bahasa_Indonesia_yang_Disempurnakan

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var id = moment.defineLocale('id', {

months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember'.split('_'),
monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nov_Des'.split('_'),
weekdays : 'Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu'.split('_'),
weekdaysShort : 'Min_Sen_Sel_Rab_Kam_Jum_Sab'.split('_'),
weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sb'.split('_'),
longDateFormat : {
    LT : 'HH.mm',
    LTS : 'HH.mm.ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY [pukul] HH.mm',
    LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
},
meridiemParse: /pagi|siang|sore|malam/,
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === 'pagi') {
        return hour;
    } else if (meridiem === 'siang') {
        return hour >= 11 ? hour : hour + 12;
    } else if (meridiem === 'sore' || meridiem === 'malam') {
        return hour + 12;
    }
},
meridiem : function (hours, minutes, isLower) {
    if (hours < 11) {
        return 'pagi';
    } else if (hours < 15) {
        return 'siang';
    } else if (hours < 19) {
        return 'sore';
    } else {
        return 'malam';
    }
},
calendar : {
    sameDay : '[Hari ini pukul] LT',
    nextDay : '[Besok pukul] LT',
    nextWeek : 'dddd [pukul] LT',
    lastDay : '[Kemarin pukul] LT',
    lastWeek : 'dddd [lalu pukul] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'dalam %s',
    past : '%s yang lalu',
    s : 'beberapa detik',
    m : 'semenit',
    mm : '%d menit',
    h : 'sejam',
    hh : '%d jam',
    d : 'sehari',
    dd : '%d hari',
    M : 'sebulan',
    MM : '%d bulan',
    y : 'setahun',
    yy : '%d tahun'
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return id;

})));

/***/ }), /* 90 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Icelandic [is] //! author : Hinrik Örn Sigurðsson : github.com/hinrik

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function plural(n) {

if (n % 100 === 11) {
    return true;
} else if (n % 10 === 1) {
    return false;
}
return true;

} function translate(number, withoutSuffix, key, isFuture) {

var result = number + ' ';
switch (key) {
    case 's':
        return withoutSuffix || isFuture ? 'nokkrar sekúndur' : 'nokkrum sekúndum';
    case 'm':
        return withoutSuffix ? 'mínúta' : 'mínútu';
    case 'mm':
        if (plural(number)) {
            return result + (withoutSuffix || isFuture ? 'mínútur' : 'mínútum');
        } else if (withoutSuffix) {
            return result + 'mínúta';
        }
        return result + 'mínútu';
    case 'hh':
        if (plural(number)) {
            return result + (withoutSuffix || isFuture ? 'klukkustundir' : 'klukkustundum');
        }
        return result + 'klukkustund';
    case 'd':
        if (withoutSuffix) {
            return 'dagur';
        }
        return isFuture ? 'dag' : 'degi';
    case 'dd':
        if (plural(number)) {
            if (withoutSuffix) {
                return result + 'dagar';
            }
            return result + (isFuture ? 'daga' : 'dögum');
        } else if (withoutSuffix) {
            return result + 'dagur';
        }
        return result + (isFuture ? 'dag' : 'degi');
    case 'M':
        if (withoutSuffix) {
            return 'mánuður';
        }
        return isFuture ? 'mánuð' : 'mánuði';
    case 'MM':
        if (plural(number)) {
            if (withoutSuffix) {
                return result + 'mánuðir';
            }
            return result + (isFuture ? 'mánuði' : 'mánuðum');
        } else if (withoutSuffix) {
            return result + 'mánuður';
        }
        return result + (isFuture ? 'mánuð' : 'mánuði');
    case 'y':
        return withoutSuffix || isFuture ? 'ár' : 'ári';
    case 'yy':
        if (plural(number)) {
            return result + (withoutSuffix || isFuture ? 'ár' : 'árum');
        }
        return result + (withoutSuffix || isFuture ? 'ár' : 'ári');
}

}

var is = moment.defineLocale('is', {

months : 'janúar_febrúar_mars_apríl_maí_júní_júlí_ágúst_september_október_nóvember_desember'.split('_'),
monthsShort : 'jan_feb_mar_apr_maí_jún_júl_ágú_sep_okt_nóv_des'.split('_'),
weekdays : 'sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur'.split('_'),
weekdaysShort : 'sun_mán_þri_mið_fim_fös_lau'.split('_'),
weekdaysMin : 'Su_Má_Þr_Mi_Fi_Fö_La'.split('_'),
longDateFormat : {
    LT : 'H:mm',
    LTS : 'H:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D. MMMM YYYY',
    LLL : 'D. MMMM YYYY [kl.] H:mm',
    LLLL : 'dddd, D. MMMM YYYY [kl.] H:mm'
},
calendar : {
    sameDay : '[í dag kl.] LT',
    nextDay : '[á morgun kl.] LT',
    nextWeek : 'dddd [kl.] LT',
    lastDay : '[í gær kl.] LT',
    lastWeek : '[síðasta] dddd [kl.] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'eftir %s',
    past : 'fyrir %s síðan',
    s : translate,
    m : translate,
    mm : translate,
    h : 'klukkustund',
    hh : translate,
    d : translate,
    dd : translate,
    M : translate,
    MM : translate,
    y : translate,
    yy : translate
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return is;

})));

/***/ }), /* 91 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Italian [it] //! author : Lorenzo : github.com/aliem //! author: Mattia Larentis: github.com/nostalgiaz

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var it = moment.defineLocale('it', {

months : 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split('_'),
monthsShort : 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
weekdays : 'domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato'.split('_'),
weekdaysShort : 'dom_lun_mar_mer_gio_ven_sab'.split('_'),
weekdaysMin : 'do_lu_ma_me_gi_ve_sa'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
calendar : {
    sameDay: '[Oggi alle] LT',
    nextDay: '[Domani alle] LT',
    nextWeek: 'dddd [alle] LT',
    lastDay: '[Ieri alle] LT',
    lastWeek: function () {
        switch (this.day()) {
            case 0:
                return '[la scorsa] dddd [alle] LT';
            default:
                return '[lo scorso] dddd [alle] LT';
        }
    },
    sameElse: 'L'
},
relativeTime : {
    future : function (s) {
        return ((/^[0-9].+$/).test(s) ? 'tra' : 'in') + ' ' + s;
    },
    past : '%s fa',
    s : 'alcuni secondi',
    m : 'un minuto',
    mm : '%d minuti',
    h : 'un\'ora',
    hh : '%d ore',
    d : 'un giorno',
    dd : '%d giorni',
    M : 'un mese',
    MM : '%d mesi',
    y : 'un anno',
    yy : '%d anni'
},
dayOfMonthOrdinalParse : /\d{1,2}º/,
ordinal: '%dº',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return it;

})));

/***/ }), /* 92 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Japanese [ja] //! author : LI Long : github.com/baryon

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var ja = moment.defineLocale('ja', {

months : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
weekdays : '日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日'.split('_'),
weekdaysShort : '日_月_火_水_木_金_土'.split('_'),
weekdaysMin : '日_月_火_水_木_金_土'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'YYYY/MM/DD',
    LL : 'YYYY年M月D日',
    LLL : 'YYYY年M月D日 HH:mm',
    LLLL : 'YYYY年M月D日 HH:mm dddd',
    l : 'YYYY/MM/DD',
    ll : 'YYYY年M月D日',
    lll : 'YYYY年M月D日 HH:mm',
    llll : 'YYYY年M月D日 HH:mm dddd'
},
meridiemParse: /午前|午後/i,
isPM : function (input) {
    return input === '午後';
},
meridiem : function (hour, minute, isLower) {
    if (hour < 12) {
        return '午前';
    } else {
        return '午後';
    }
},
calendar : {
    sameDay : '[今日] LT',
    nextDay : '[明日] LT',
    nextWeek : '[来週]dddd LT',
    lastDay : '[昨日] LT',
    lastWeek : '[前週]dddd LT',
    sameElse : 'L'
},
dayOfMonthOrdinalParse : /\d{1,2}日/,
ordinal : function (number, period) {
    switch (period) {
        case 'd':
        case 'D':
        case 'DDD':
            return number + '日';
        default:
            return number;
    }
},
relativeTime : {
    future : '%s後',
    past : '%s前',
    s : '数秒',
    m : '1分',
    mm : '%d分',
    h : '1時間',
    hh : '%d時間',
    d : '1日',
    dd : '%d日',
    M : '1ヶ月',
    MM : '%dヶ月',
    y : '1年',
    yy : '%d年'
}

});

return ja;

})));

/***/ }), /* 93 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Javanese [jv] //! author : Rony Lantip : github.com/lantip //! reference: jv.wikipedia.org/wiki/Basa_Jawa

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var jv = moment.defineLocale('jv', {

months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember'.split('_'),
monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des'.split('_'),
weekdays : 'Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu'.split('_'),
weekdaysShort : 'Min_Sen_Sel_Reb_Kem_Jem_Sep'.split('_'),
weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sp'.split('_'),
longDateFormat : {
    LT : 'HH.mm',
    LTS : 'HH.mm.ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY [pukul] HH.mm',
    LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
},
meridiemParse: /enjing|siyang|sonten|ndalu/,
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === 'enjing') {
        return hour;
    } else if (meridiem === 'siyang') {
        return hour >= 11 ? hour : hour + 12;
    } else if (meridiem === 'sonten' || meridiem === 'ndalu') {
        return hour + 12;
    }
},
meridiem : function (hours, minutes, isLower) {
    if (hours < 11) {
        return 'enjing';
    } else if (hours < 15) {
        return 'siyang';
    } else if (hours < 19) {
        return 'sonten';
    } else {
        return 'ndalu';
    }
},
calendar : {
    sameDay : '[Dinten puniko pukul] LT',
    nextDay : '[Mbenjang pukul] LT',
    nextWeek : 'dddd [pukul] LT',
    lastDay : '[Kala wingi pukul] LT',
    lastWeek : 'dddd [kepengker pukul] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'wonten ing %s',
    past : '%s ingkang kepengker',
    s : 'sawetawis detik',
    m : 'setunggal menit',
    mm : '%d menit',
    h : 'setunggal jam',
    hh : '%d jam',
    d : 'sedinten',
    dd : '%d dinten',
    M : 'sewulan',
    MM : '%d wulan',
    y : 'setaun',
    yy : '%d taun'
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return jv;

})));

/***/ }), /* 94 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Georgian [ka] //! author : Irakli Janiashvili : github.com/irakli-janiashvili

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var ka = moment.defineLocale('ka', {

months : {
    standalone: 'იანვარი_თებერვალი_მარტი_აპრილი_მაისი_ივნისი_ივლისი_აგვისტო_სექტემბერი_ოქტომბერი_ნოემბერი_დეკემბერი'.split('_'),
    format: 'იანვარს_თებერვალს_მარტს_აპრილის_მაისს_ივნისს_ივლისს_აგვისტს_სექტემბერს_ოქტომბერს_ნოემბერს_დეკემბერს'.split('_')
},
monthsShort : 'იან_თებ_მარ_აპრ_მაი_ივნ_ივლ_აგვ_სექ_ოქტ_ნოე_დეკ'.split('_'),
weekdays : {
    standalone: 'კვირა_ორშაბათი_სამშაბათი_ოთხშაბათი_ხუთშაბათი_პარასკევი_შაბათი'.split('_'),
    format: 'კვირას_ორშაბათს_სამშაბათს_ოთხშაბათს_ხუთშაბათს_პარასკევს_შაბათს'.split('_'),
    isFormat: /(წინა|შემდეგ)/
},
weekdaysShort : 'კვი_ორშ_სამ_ოთხ_ხუთ_პარ_შაბ'.split('_'),
weekdaysMin : 'კვ_ორ_სა_ოთ_ხუ_პა_შა'.split('_'),
longDateFormat : {
    LT : 'h:mm A',
    LTS : 'h:mm:ss A',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY h:mm A',
    LLLL : 'dddd, D MMMM YYYY h:mm A'
},
calendar : {
    sameDay : '[დღეს] LT[-ზე]',
    nextDay : '[ხვალ] LT[-ზე]',
    lastDay : '[გუშინ] LT[-ზე]',
    nextWeek : '[შემდეგ] dddd LT[-ზე]',
    lastWeek : '[წინა] dddd LT-ზე',
    sameElse : 'L'
},
relativeTime : {
    future : function (s) {
        return (/(წამი|წუთი|საათი|წელი)/).test(s) ?
            s.replace(/ი$/, 'ში') :
            s + 'ში';
    },
    past : function (s) {
        if ((/(წამი|წუთი|საათი|დღე|თვე)/).test(s)) {
            return s.replace(/(ი|ე)$/, 'ის უკან');
        }
        if ((/წელი/).test(s)) {
            return s.replace(/წელი$/, 'წლის უკან');
        }
    },
    s : 'რამდენიმე წამი',
    m : 'წუთი',
    mm : '%d წუთი',
    h : 'საათი',
    hh : '%d საათი',
    d : 'დღე',
    dd : '%d დღე',
    M : 'თვე',
    MM : '%d თვე',
    y : 'წელი',
    yy : '%d წელი'
},
dayOfMonthOrdinalParse: /0|1-ლი|მე-\d{1,2}|\d{1,2}-ე/,
ordinal : function (number) {
    if (number === 0) {
        return number;
    }
    if (number === 1) {
        return number + '-ლი';
    }
    if ((number < 20) || (number <= 100 && (number % 20 === 0)) || (number % 100 === 0)) {
        return 'მე-' + number;
    }
    return number + '-ე';
},
week : {
    dow : 1,
    doy : 7
}

});

return ka;

})));

/***/ }), /* 95 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Kazakh [kk] //! authors : Nurlan Rakhimzhanov : github.com/nurlan

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var suffixes = {

0: '-ші',
1: '-ші',
2: '-ші',
3: '-ші',
4: '-ші',
5: '-ші',
6: '-шы',
7: '-ші',
8: '-ші',
9: '-шы',
10: '-шы',
20: '-шы',
30: '-шы',
40: '-шы',
50: '-ші',
60: '-шы',
70: '-ші',
80: '-ші',
90: '-шы',
100: '-ші'

};

var kk = moment.defineLocale('kk', {

months : 'қаңтар_ақпан_наурыз_сәуір_мамыр_маусым_шілде_тамыз_қыркүйек_қазан_қараша_желтоқсан'.split('_'),
monthsShort : 'қаң_ақп_нау_сәу_мам_мау_шіл_там_қыр_қаз_қар_жел'.split('_'),
weekdays : 'жексенбі_дүйсенбі_сейсенбі_сәрсенбі_бейсенбі_жұма_сенбі'.split('_'),
weekdaysShort : 'жек_дүй_сей_сәр_бей_жұм_сен'.split('_'),
weekdaysMin : 'жк_дй_сй_ср_бй_жм_сн'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
calendar : {
    sameDay : '[Бүгін сағат] LT',
    nextDay : '[Ертең сағат] LT',
    nextWeek : 'dddd [сағат] LT',
    lastDay : '[Кеше сағат] LT',
    lastWeek : '[Өткен аптаның] dddd [сағат] LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s ішінде',
    past : '%s бұрын',
    s : 'бірнеше секунд',
    m : 'бір минут',
    mm : '%d минут',
    h : 'бір сағат',
    hh : '%d сағат',
    d : 'бір күн',
    dd : '%d күн',
    M : 'бір ай',
    MM : '%d ай',
    y : 'бір жыл',
    yy : '%d жыл'
},
dayOfMonthOrdinalParse: /\d{1,2}-(ші|шы)/,
ordinal : function (number) {
    var a = number % 10,
        b = number >= 100 ? 100 : null;
    return number + (suffixes[number] || suffixes[a] || suffixes[b]);
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return kk;

})));

/***/ }), /* 96 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Cambodian [km] //! author : Kruy Vanna : github.com/kruyvanna

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var km = moment.defineLocale('km', {

months: 'មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split('_'),
monthsShort: 'មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split('_'),
weekdays: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
weekdaysShort: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
weekdaysMin: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
longDateFormat: {
    LT: 'HH:mm',
    LTS : 'HH:mm:ss',
    L: 'DD/MM/YYYY',
    LL: 'D MMMM YYYY',
    LLL: 'D MMMM YYYY HH:mm',
    LLLL: 'dddd, D MMMM YYYY HH:mm'
},
calendar: {
    sameDay: '[ថ្ងៃនេះ ម៉ោង] LT',
    nextDay: '[ស្អែក ម៉ោង] LT',
    nextWeek: 'dddd [ម៉ោង] LT',
    lastDay: '[ម្សិលមិញ ម៉ោង] LT',
    lastWeek: 'dddd [សប្តាហ៍មុន] [ម៉ោង] LT',
    sameElse: 'L'
},
relativeTime: {
    future: '%sទៀត',
    past: '%sមុន',
    s: 'ប៉ុន្មានវិនាទី',
    m: 'មួយនាទី',
    mm: '%d នាទី',
    h: 'មួយម៉ោង',
    hh: '%d ម៉ោង',
    d: 'មួយថ្ងៃ',
    dd: '%d ថ្ងៃ',
    M: 'មួយខែ',
    MM: '%d ខែ',
    y: 'មួយឆ្នាំ',
    yy: '%d ឆ្នាំ'
},
week: {
    dow: 1, // Monday is the first day of the week.
    doy: 4 // The week that contains Jan 4th is the first week of the year.
}

});

return km;

})));

/***/ }), /* 97 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Kannada [kn] //! author : Rajeev Naik : github.com/rajeevnaikte

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var symbolMap = {

'1': '೧',
'2': '೨',
'3': '೩',
'4': '೪',
'5': '೫',
'6': '೬',
'7': '೭',
'8': '೮',
'9': '೯',
'0': '೦'

}; var numberMap = {

'೧': '1',
'೨': '2',
'೩': '3',
'೪': '4',
'೫': '5',
'೬': '6',
'೭': '7',
'೮': '8',
'೯': '9',
'೦': '0'

};

var kn = moment.defineLocale('kn', {

months : 'ಜನವರಿ_ಫೆಬ್ರವರಿ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂಬರ್_ಅಕ್ಟೋಬರ್_ನವೆಂಬರ್_ಡಿಸೆಂಬರ್'.split('_'),
monthsShort : 'ಜನ_ಫೆಬ್ರ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂಬ_ಅಕ್ಟೋಬ_ನವೆಂಬ_ಡಿಸೆಂಬ'.split('_'),
monthsParseExact: true,
weekdays : 'ಭಾನುವಾರ_ಸೋಮವಾರ_ಮಂಗಳವಾರ_ಬುಧವಾರ_ಗುರುವಾರ_ಶುಕ್ರವಾರ_ಶನಿವಾರ'.split('_'),
weekdaysShort : 'ಭಾನು_ಸೋಮ_ಮಂಗಳ_ಬುಧ_ಗುರು_ಶುಕ್ರ_ಶನಿ'.split('_'),
weekdaysMin : 'ಭಾ_ಸೋ_ಮಂ_ಬು_ಗು_ಶು_ಶ'.split('_'),
longDateFormat : {
    LT : 'A h:mm',
    LTS : 'A h:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY, A h:mm',
    LLLL : 'dddd, D MMMM YYYY, A h:mm'
},
calendar : {
    sameDay : '[ಇಂದು] LT',
    nextDay : '[ನಾಳೆ] LT',
    nextWeek : 'dddd, LT',
    lastDay : '[ನಿನ್ನೆ] LT',
    lastWeek : '[ಕೊನೆಯ] dddd, LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s ನಂತರ',
    past : '%s ಹಿಂದೆ',
    s : 'ಕೆಲವು ಕ್ಷಣಗಳು',
    m : 'ಒಂದು ನಿಮಿಷ',
    mm : '%d ನಿಮಿಷ',
    h : 'ಒಂದು ಗಂಟೆ',
    hh : '%d ಗಂಟೆ',
    d : 'ಒಂದು ದಿನ',
    dd : '%d ದಿನ',
    M : 'ಒಂದು ತಿಂಗಳು',
    MM : '%d ತಿಂಗಳು',
    y : 'ಒಂದು ವರ್ಷ',
    yy : '%d ವರ್ಷ'
},
preparse: function (string) {
    return string.replace(/[೧೨೩೪೫೬೭೮೯೦]/g, function (match) {
        return numberMap[match];
    });
},
postformat: function (string) {
    return string.replace(/\d/g, function (match) {
        return symbolMap[match];
    });
},
meridiemParse: /ರಾತ್ರಿ|ಬೆಳಿಗ್ಗೆ|ಮಧ್ಯಾಹ್ನ|ಸಂಜೆ/,
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === 'ರಾತ್ರಿ') {
        return hour < 4 ? hour : hour + 12;
    } else if (meridiem === 'ಬೆಳಿಗ್ಗೆ') {
        return hour;
    } else if (meridiem === 'ಮಧ್ಯಾಹ್ನ') {
        return hour >= 10 ? hour : hour + 12;
    } else if (meridiem === 'ಸಂಜೆ') {
        return hour + 12;
    }
},
meridiem : function (hour, minute, isLower) {
    if (hour < 4) {
        return 'ರಾತ್ರಿ';
    } else if (hour < 10) {
        return 'ಬೆಳಿಗ್ಗೆ';
    } else if (hour < 17) {
        return 'ಮಧ್ಯಾಹ್ನ';
    } else if (hour < 20) {
        return 'ಸಂಜೆ';
    } else {
        return 'ರಾತ್ರಿ';
    }
},
dayOfMonthOrdinalParse: /\d{1,2}(ನೇ)/,
ordinal : function (number) {
    return number + 'ನೇ';
},
week : {
    dow : 0, // Sunday is the first day of the week.
    doy : 6  // The week that contains Jan 1st is the first week of the year.
}

});

return kn;

})));

/***/ }), /* 98 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Korean [ko] //! author : Kyungwook, Park : github.com/kyungw00k //! author : Jeeeyul Lee <jeeeyul@gmail.com>

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var ko = moment.defineLocale('ko', {

months : '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
monthsShort : '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
weekdays : '일요일_월요일_화요일_수요일_목요일_금요일_토요일'.split('_'),
weekdaysShort : '일_월_화_수_목_금_토'.split('_'),
weekdaysMin : '일_월_화_수_목_금_토'.split('_'),
longDateFormat : {
    LT : 'A h:mm',
    LTS : 'A h:mm:ss',
    L : 'YYYY.MM.DD',
    LL : 'YYYY년 MMMM D일',
    LLL : 'YYYY년 MMMM D일 A h:mm',
    LLLL : 'YYYY년 MMMM D일 dddd A h:mm',
    l : 'YYYY.MM.DD',
    ll : 'YYYY년 MMMM D일',
    lll : 'YYYY년 MMMM D일 A h:mm',
    llll : 'YYYY년 MMMM D일 dddd A h:mm'
},
calendar : {
    sameDay : '오늘 LT',
    nextDay : '내일 LT',
    nextWeek : 'dddd LT',
    lastDay : '어제 LT',
    lastWeek : '지난주 dddd LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s 후',
    past : '%s 전',
    s : '몇 초',
    ss : '%d초',
    m : '1분',
    mm : '%d분',
    h : '한 시간',
    hh : '%d시간',
    d : '하루',
    dd : '%d일',
    M : '한 달',
    MM : '%d달',
    y : '일 년',
    yy : '%d년'
},
dayOfMonthOrdinalParse : /\d{1,2}일/,
ordinal : '%d일',
meridiemParse : /오전|오후/,
isPM : function (token) {
    return token === '오후';
},
meridiem : function (hour, minute, isUpper) {
    return hour < 12 ? '오전' : '오후';
}

});

return ko;

})));

/***/ }), /* 99 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Kyrgyz [ky] //! author : Chyngyz Arystan uulu : github.com/chyngyz

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var suffixes = {

0: '-чү',
1: '-чи',
2: '-чи',
3: '-чү',
4: '-чү',
5: '-чи',
6: '-чы',
7: '-чи',
8: '-чи',
9: '-чу',
10: '-чу',
20: '-чы',
30: '-чу',
40: '-чы',
50: '-чү',
60: '-чы',
70: '-чи',
80: '-чи',
90: '-чу',
100: '-чү'

};

var ky = moment.defineLocale('ky', {

months : 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_'),
monthsShort : 'янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split('_'),
weekdays : 'Жекшемби_Дүйшөмбү_Шейшемби_Шаршемби_Бейшемби_Жума_Ишемби'.split('_'),
weekdaysShort : 'Жек_Дүй_Шей_Шар_Бей_Жум_Ише'.split('_'),
weekdaysMin : 'Жк_Дй_Шй_Шр_Бй_Жм_Иш'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
calendar : {
    sameDay : '[Бүгүн саат] LT',
    nextDay : '[Эртең саат] LT',
    nextWeek : 'dddd [саат] LT',
    lastDay : '[Кече саат] LT',
    lastWeek : '[Өткен аптанын] dddd [күнү] [саат] LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s ичинде',
    past : '%s мурун',
    s : 'бирнече секунд',
    m : 'бир мүнөт',
    mm : '%d мүнөт',
    h : 'бир саат',
    hh : '%d саат',
    d : 'бир күн',
    dd : '%d күн',
    M : 'бир ай',
    MM : '%d ай',
    y : 'бир жыл',
    yy : '%d жыл'
},
dayOfMonthOrdinalParse: /\d{1,2}-(чи|чы|чү|чу)/,
ordinal : function (number) {
    var a = number % 10,
        b = number >= 100 ? 100 : null;
    return number + (suffixes[number] || suffixes[a] || suffixes[b]);
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return ky;

})));

/***/ }), /* 100 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Luxembourgish [lb] //! author : mweimerskirch : github.com/mweimerskirch //! author : David Raison : github.com/kwisatz

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function processRelativeTime(number, withoutSuffix, key, isFuture) {

var format = {
    'm': ['eng Minutt', 'enger Minutt'],
    'h': ['eng Stonn', 'enger Stonn'],
    'd': ['een Dag', 'engem Dag'],
    'M': ['ee Mount', 'engem Mount'],
    'y': ['ee Joer', 'engem Joer']
};
return withoutSuffix ? format[key][0] : format[key][1];

} function processFutureTime(string) {

var number = string.substr(0, string.indexOf(' '));
if (eifelerRegelAppliesToNumber(number)) {
    return 'a ' + string;
}
return 'an ' + string;

} function processPastTime(string) {

var number = string.substr(0, string.indexOf(' '));
if (eifelerRegelAppliesToNumber(number)) {
    return 'viru ' + string;
}
return 'virun ' + string;

} /**

* Returns true if the word before the given number loses the '-n' ending.
* e.g. 'an 10 Deeg' but 'a 5 Deeg'
*
* @param number {integer}
* @returns {boolean}
*/

function eifelerRegelAppliesToNumber(number) {

number = parseInt(number, 10);
if (isNaN(number)) {
    return false;
}
if (number < 0) {
    // Negative Number --> always true
    return true;
} else if (number < 10) {
    // Only 1 digit
    if (4 <= number && number <= 7) {
        return true;
    }
    return false;
} else if (number < 100) {
    // 2 digits
    var lastDigit = number % 10, firstDigit = number / 10;
    if (lastDigit === 0) {
        return eifelerRegelAppliesToNumber(firstDigit);
    }
    return eifelerRegelAppliesToNumber(lastDigit);
} else if (number < 10000) {
    // 3 or 4 digits --> recursively check first digit
    while (number >= 10) {
        number = number / 10;
    }
    return eifelerRegelAppliesToNumber(number);
} else {
    // Anything larger than 4 digits: recursively check first n-3 digits
    number = number / 1000;
    return eifelerRegelAppliesToNumber(number);
}

}

var lb = moment.defineLocale('lb', {

months: 'Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
monthsShort: 'Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
monthsParseExact : true,
weekdays: 'Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg'.split('_'),
weekdaysShort: 'So._Mé._Dë._Më._Do._Fr._Sa.'.split('_'),
weekdaysMin: 'So_Mé_Dë_Më_Do_Fr_Sa'.split('_'),
weekdaysParseExact : true,
longDateFormat: {
    LT: 'H:mm [Auer]',
    LTS: 'H:mm:ss [Auer]',
    L: 'DD.MM.YYYY',
    LL: 'D. MMMM YYYY',
    LLL: 'D. MMMM YYYY H:mm [Auer]',
    LLLL: 'dddd, D. MMMM YYYY H:mm [Auer]'
},
calendar: {
    sameDay: '[Haut um] LT',
    sameElse: 'L',
    nextDay: '[Muer um] LT',
    nextWeek: 'dddd [um] LT',
    lastDay: '[Gëschter um] LT',
    lastWeek: function () {
        // Different date string for 'Dënschdeg' (Tuesday) and 'Donneschdeg' (Thursday) due to phonological rule
        switch (this.day()) {
            case 2:
            case 4:
                return '[Leschten] dddd [um] LT';
            default:
                return '[Leschte] dddd [um] LT';
        }
    }
},
relativeTime : {
    future : processFutureTime,
    past : processPastTime,
    s : 'e puer Sekonnen',
    m : processRelativeTime,
    mm : '%d Minutten',
    h : processRelativeTime,
    hh : '%d Stonnen',
    d : processRelativeTime,
    dd : '%d Deeg',
    M : processRelativeTime,
    MM : '%d Méint',
    y : processRelativeTime,
    yy : '%d Joer'
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal: '%d.',
week: {
    dow: 1, // Monday is the first day of the week.
    doy: 4  // The week that contains Jan 4th is the first week of the year.
}

});

return lb;

})));

/***/ }), /* 101 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Lao [lo] //! author : Ryan Hart : github.com/ryanhart2

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var lo = moment.defineLocale('lo', {

months : 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split('_'),
monthsShort : 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split('_'),
weekdays : 'ອາທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
weekdaysShort : 'ທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
weekdaysMin : 'ທ_ຈ_ອຄ_ພ_ພຫ_ສກ_ສ'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'ວັນdddd D MMMM YYYY HH:mm'
},
meridiemParse: /ຕອນເຊົ້າ|ຕອນແລງ/,
isPM: function (input) {
    return input === 'ຕອນແລງ';
},
meridiem : function (hour, minute, isLower) {
    if (hour < 12) {
        return 'ຕອນເຊົ້າ';
    } else {
        return 'ຕອນແລງ';
    }
},
calendar : {
    sameDay : '[ມື້ນີ້ເວລາ] LT',
    nextDay : '[ມື້ອື່ນເວລາ] LT',
    nextWeek : '[ວັນ]dddd[ໜ້າເວລາ] LT',
    lastDay : '[ມື້ວານນີ້ເວລາ] LT',
    lastWeek : '[ວັນ]dddd[ແລ້ວນີ້ເວລາ] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'ອີກ %s',
    past : '%sຜ່ານມາ',
    s : 'ບໍ່ເທົ່າໃດວິນາທີ',
    m : '1 ນາທີ',
    mm : '%d ນາທີ',
    h : '1 ຊົ່ວໂມງ',
    hh : '%d ຊົ່ວໂມງ',
    d : '1 ມື້',
    dd : '%d ມື້',
    M : '1 ເດືອນ',
    MM : '%d ເດືອນ',
    y : '1 ປີ',
    yy : '%d ປີ'
},
dayOfMonthOrdinalParse: /(ທີ່)\d{1,2}/,
ordinal : function (number) {
    return 'ທີ່' + number;
}

});

return lo;

})));

/***/ }), /* 102 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Lithuanian [lt] //! author : Mindaugas Mozūras : github.com/mmozuras

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var units = {

'm' : 'minutė_minutės_minutę',
'mm': 'minutės_minučių_minutes',
'h' : 'valanda_valandos_valandą',
'hh': 'valandos_valandų_valandas',
'd' : 'diena_dienos_dieną',
'dd': 'dienos_dienų_dienas',
'M' : 'mėnuo_mėnesio_mėnesį',
'MM': 'mėnesiai_mėnesių_mėnesius',
'y' : 'metai_metų_metus',
'yy': 'metai_metų_metus'

}; function translateSeconds(number, withoutSuffix, key, isFuture) {

if (withoutSuffix) {
    return 'kelios sekundės';
} else {
    return isFuture ? 'kelių sekundžių' : 'kelias sekundes';
}

} function translateSingular(number, withoutSuffix, key, isFuture) {

return withoutSuffix ? forms(key)[0] : (isFuture ? forms(key)[1] : forms(key)[2]);

} function special(number) {

return number % 10 === 0 || (number > 10 && number < 20);

} function forms(key) {

return units[key].split('_');

} function translate(number, withoutSuffix, key, isFuture) {

var result = number + ' ';
if (number === 1) {
    return result + translateSingular(number, withoutSuffix, key[0], isFuture);
} else if (withoutSuffix) {
    return result + (special(number) ? forms(key)[1] : forms(key)[0]);
} else {
    if (isFuture) {
        return result + forms(key)[1];
    } else {
        return result + (special(number) ? forms(key)[1] : forms(key)[2]);
    }
}

} var lt = moment.defineLocale('lt', {

months : {
    format: 'sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjūčio_rugsėjo_spalio_lapkričio_gruodžio'.split('_'),
    standalone: 'sausis_vasaris_kovas_balandis_gegužė_birželis_liepa_rugpjūtis_rugsėjis_spalis_lapkritis_gruodis'.split('_'),
    isFormat: /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?|MMMM?(\[[^\[\]]*\]|\s)+D[oD]?/
},
monthsShort : 'sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd'.split('_'),
weekdays : {
    format: 'sekmadienį_pirmadienį_antradienį_trečiadienį_ketvirtadienį_penktadienį_šeštadienį'.split('_'),
    standalone: 'sekmadienis_pirmadienis_antradienis_trečiadienis_ketvirtadienis_penktadienis_šeštadienis'.split('_'),
    isFormat: /dddd HH:mm/
},
weekdaysShort : 'Sek_Pir_Ant_Tre_Ket_Pen_Šeš'.split('_'),
weekdaysMin : 'S_P_A_T_K_Pn_Š'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'YYYY-MM-DD',
    LL : 'YYYY [m.] MMMM D [d.]',
    LLL : 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
    LLLL : 'YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]',
    l : 'YYYY-MM-DD',
    ll : 'YYYY [m.] MMMM D [d.]',
    lll : 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
    llll : 'YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]'
},
calendar : {
    sameDay : '[Šiandien] LT',
    nextDay : '[Rytoj] LT',
    nextWeek : 'dddd LT',
    lastDay : '[Vakar] LT',
    lastWeek : '[Praėjusį] dddd LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'po %s',
    past : 'prieš %s',
    s : translateSeconds,
    m : translateSingular,
    mm : translate,
    h : translateSingular,
    hh : translate,
    d : translateSingular,
    dd : translate,
    M : translateSingular,
    MM : translate,
    y : translateSingular,
    yy : translate
},
dayOfMonthOrdinalParse: /\d{1,2}-oji/,
ordinal : function (number) {
    return number + '-oji';
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return lt;

})));

/***/ }), /* 103 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Latvian [lv] //! author : Kristaps Karlsons : github.com/skakri //! author : Jānis Elmeris : github.com/JanisE

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var units = {

'm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
'mm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
'h': 'stundas_stundām_stunda_stundas'.split('_'),
'hh': 'stundas_stundām_stunda_stundas'.split('_'),
'd': 'dienas_dienām_diena_dienas'.split('_'),
'dd': 'dienas_dienām_diena_dienas'.split('_'),
'M': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
'MM': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
'y': 'gada_gadiem_gads_gadi'.split('_'),
'yy': 'gada_gadiem_gads_gadi'.split('_')

}; /**

* @param withoutSuffix boolean true = a length of time; false = before/after a period of time.
*/

function format(forms, number, withoutSuffix) {

if (withoutSuffix) {
    // E.g. "21 minūte", "3 minūtes".
    return number % 10 === 1 && number % 100 !== 11 ? forms[2] : forms[3];
} else {
    // E.g. "21 minūtes" as in "pēc 21 minūtes".
    // E.g. "3 minūtēm" as in "pēc 3 minūtēm".
    return number % 10 === 1 && number % 100 !== 11 ? forms[0] : forms[1];
}

} function relativeTimeWithPlural(number, withoutSuffix, key) {

return number + ' ' + format(units[key], number, withoutSuffix);

} function relativeTimeWithSingular(number, withoutSuffix, key) {

return format(units[key], number, withoutSuffix);

} function relativeSeconds(number, withoutSuffix) {

return withoutSuffix ? 'dažas sekundes' : 'dažām sekundēm';

}

var lv = moment.defineLocale('lv', {

months : 'janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris'.split('_'),
monthsShort : 'jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec'.split('_'),
weekdays : 'svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena'.split('_'),
weekdaysShort : 'Sv_P_O_T_C_Pk_S'.split('_'),
weekdaysMin : 'Sv_P_O_T_C_Pk_S'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY.',
    LL : 'YYYY. [gada] D. MMMM',
    LLL : 'YYYY. [gada] D. MMMM, HH:mm',
    LLLL : 'YYYY. [gada] D. MMMM, dddd, HH:mm'
},
calendar : {
    sameDay : '[Šodien pulksten] LT',
    nextDay : '[Rīt pulksten] LT',
    nextWeek : 'dddd [pulksten] LT',
    lastDay : '[Vakar pulksten] LT',
    lastWeek : '[Pagājušā] dddd [pulksten] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'pēc %s',
    past : 'pirms %s',
    s : relativeSeconds,
    m : relativeTimeWithSingular,
    mm : relativeTimeWithPlural,
    h : relativeTimeWithSingular,
    hh : relativeTimeWithPlural,
    d : relativeTimeWithSingular,
    dd : relativeTimeWithPlural,
    M : relativeTimeWithSingular,
    MM : relativeTimeWithPlural,
    y : relativeTimeWithSingular,
    yy : relativeTimeWithPlural
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return lv;

})));

/***/ }), /* 104 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Montenegrin [me] //! author : Miodrag Nikač <miodrag@restartit.me> : github.com/miodragnikac

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var translator = {

words: { //Different grammatical cases
    m: ['jedan minut', 'jednog minuta'],
    mm: ['minut', 'minuta', 'minuta'],
    h: ['jedan sat', 'jednog sata'],
    hh: ['sat', 'sata', 'sati'],
    dd: ['dan', 'dana', 'dana'],
    MM: ['mjesec', 'mjeseca', 'mjeseci'],
    yy: ['godina', 'godine', 'godina']
},
correctGrammaticalCase: function (number, wordKey) {
    return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
},
translate: function (number, withoutSuffix, key) {
    var wordKey = translator.words[key];
    if (key.length === 1) {
        return withoutSuffix ? wordKey[0] : wordKey[1];
    } else {
        return number + ' ' + translator.correctGrammaticalCase(number, wordKey);
    }
}

};

var me = moment.defineLocale('me', {

months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'),
monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'),
monthsParseExact : true,
weekdays: 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
weekdaysShort: 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
weekdaysMin: 'ne_po_ut_sr_če_pe_su'.split('_'),
weekdaysParseExact : true,
longDateFormat: {
    LT: 'H:mm',
    LTS : 'H:mm:ss',
    L: 'DD.MM.YYYY',
    LL: 'D. MMMM YYYY',
    LLL: 'D. MMMM YYYY H:mm',
    LLLL: 'dddd, D. MMMM YYYY H:mm'
},
calendar: {
    sameDay: '[danas u] LT',
    nextDay: '[sjutra u] LT',

    nextWeek: function () {
        switch (this.day()) {
            case 0:
                return '[u] [nedjelju] [u] LT';
            case 3:
                return '[u] [srijedu] [u] LT';
            case 6:
                return '[u] [subotu] [u] LT';
            case 1:
            case 2:
            case 4:
            case 5:
                return '[u] dddd [u] LT';
        }
    },
    lastDay  : '[juče u] LT',
    lastWeek : function () {
        var lastWeekDays = [
            '[prošle] [nedjelje] [u] LT',
            '[prošlog] [ponedjeljka] [u] LT',
            '[prošlog] [utorka] [u] LT',
            '[prošle] [srijede] [u] LT',
            '[prošlog] [četvrtka] [u] LT',
            '[prošlog] [petka] [u] LT',
            '[prošle] [subote] [u] LT'
        ];
        return lastWeekDays[this.day()];
    },
    sameElse : 'L'
},
relativeTime : {
    future : 'za %s',
    past   : 'prije %s',
    s      : 'nekoliko sekundi',
    m      : translator.translate,
    mm     : translator.translate,
    h      : translator.translate,
    hh     : translator.translate,
    d      : 'dan',
    dd     : translator.translate,
    M      : 'mjesec',
    MM     : translator.translate,
    y      : 'godinu',
    yy     : translator.translate
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return me;

})));

/***/ }), /* 105 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Maori [mi] //! author : John Corrigan <robbiecloset@gmail.com> : github.com/johnideal

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var mi = moment.defineLocale('mi', {

months: 'Kohi-tāte_Hui-tanguru_Poutū-te-rangi_Paenga-whāwhā_Haratua_Pipiri_Hōngoingoi_Here-turi-kōkā_Mahuru_Whiringa-ā-nuku_Whiringa-ā-rangi_Hakihea'.split('_'),
monthsShort: 'Kohi_Hui_Pou_Pae_Hara_Pipi_Hōngoi_Here_Mahu_Whi-nu_Whi-ra_Haki'.split('_'),
monthsRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
monthsStrictRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
monthsShortRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
monthsShortStrictRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,2}/i,
weekdays: 'Rātapu_Mane_Tūrei_Wenerei_Tāite_Paraire_Hātarei'.split('_'),
weekdaysShort: 'Ta_Ma_Tū_We_Tāi_Pa_Hā'.split('_'),
weekdaysMin: 'Ta_Ma_Tū_We_Tāi_Pa_Hā'.split('_'),
longDateFormat: {
    LT: 'HH:mm',
    LTS: 'HH:mm:ss',
    L: 'DD/MM/YYYY',
    LL: 'D MMMM YYYY',
    LLL: 'D MMMM YYYY [i] HH:mm',
    LLLL: 'dddd, D MMMM YYYY [i] HH:mm'
},
calendar: {
    sameDay: '[i teie mahana, i] LT',
    nextDay: '[apopo i] LT',
    nextWeek: 'dddd [i] LT',
    lastDay: '[inanahi i] LT',
    lastWeek: 'dddd [whakamutunga i] LT',
    sameElse: 'L'
},
relativeTime: {
    future: 'i roto i %s',
    past: '%s i mua',
    s: 'te hēkona ruarua',
    m: 'he meneti',
    mm: '%d meneti',
    h: 'te haora',
    hh: '%d haora',
    d: 'he ra',
    dd: '%d ra',
    M: 'he marama',
    MM: '%d marama',
    y: 'he tau',
    yy: '%d tau'
},
dayOfMonthOrdinalParse: /\d{1,2}º/,
ordinal: '%dº',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return mi;

})));

/***/ }), /* 106 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Macedonian [mk] //! author : Borislav Mickov : github.com/B0k0

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var mk = moment.defineLocale('mk', {

months : 'јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември'.split('_'),
monthsShort : 'јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек'.split('_'),
weekdays : 'недела_понеделник_вторник_среда_четврток_петок_сабота'.split('_'),
weekdaysShort : 'нед_пон_вто_сре_чет_пет_саб'.split('_'),
weekdaysMin : 'нe_пo_вт_ср_че_пе_сa'.split('_'),
longDateFormat : {
    LT : 'H:mm',
    LTS : 'H:mm:ss',
    L : 'D.MM.YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY H:mm',
    LLLL : 'dddd, D MMMM YYYY H:mm'
},
calendar : {
    sameDay : '[Денес во] LT',
    nextDay : '[Утре во] LT',
    nextWeek : '[Во] dddd [во] LT',
    lastDay : '[Вчера во] LT',
    lastWeek : function () {
        switch (this.day()) {
            case 0:
            case 3:
            case 6:
                return '[Изминатата] dddd [во] LT';
            case 1:
            case 2:
            case 4:
            case 5:
                return '[Изминатиот] dddd [во] LT';
        }
    },
    sameElse : 'L'
},
relativeTime : {
    future : 'после %s',
    past : 'пред %s',
    s : 'неколку секунди',
    m : 'минута',
    mm : '%d минути',
    h : 'час',
    hh : '%d часа',
    d : 'ден',
    dd : '%d дена',
    M : 'месец',
    MM : '%d месеци',
    y : 'година',
    yy : '%d години'
},
dayOfMonthOrdinalParse: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
ordinal : function (number) {
    var lastDigit = number % 10,
        last2Digits = number % 100;
    if (number === 0) {
        return number + '-ев';
    } else if (last2Digits === 0) {
        return number + '-ен';
    } else if (last2Digits > 10 && last2Digits < 20) {
        return number + '-ти';
    } else if (lastDigit === 1) {
        return number + '-ви';
    } else if (lastDigit === 2) {
        return number + '-ри';
    } else if (lastDigit === 7 || lastDigit === 8) {
        return number + '-ми';
    } else {
        return number + '-ти';
    }
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return mk;

})));

/***/ }), /* 107 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Malayalam [ml] //! author : Floyd Pink : github.com/floydpink

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var ml = moment.defineLocale('ml', {

months : 'ജനുവരി_ഫെബ്രുവരി_മാർച്ച്_ഏപ്രിൽ_മേയ്_ജൂൺ_ജൂലൈ_ഓഗസ്റ്റ്_സെപ്റ്റംബർ_ഒക്ടോബർ_നവംബർ_ഡിസംബർ'.split('_'),
monthsShort : 'ജനു._ഫെബ്രു._മാർ._ഏപ്രി._മേയ്_ജൂൺ_ജൂലൈ._ഓഗ._സെപ്റ്റ._ഒക്ടോ._നവം._ഡിസം.'.split('_'),
monthsParseExact : true,
weekdays : 'ഞായറാഴ്ച_തിങ്കളാഴ്ച_ചൊവ്വാഴ്ച_ബുധനാഴ്ച_വ്യാഴാഴ്ച_വെള്ളിയാഴ്ച_ശനിയാഴ്ച'.split('_'),
weekdaysShort : 'ഞായർ_തിങ്കൾ_ചൊവ്വ_ബുധൻ_വ്യാഴം_വെള്ളി_ശനി'.split('_'),
weekdaysMin : 'ഞാ_തി_ചൊ_ബു_വ്യാ_വെ_ശ'.split('_'),
longDateFormat : {
    LT : 'A h:mm -നു',
    LTS : 'A h:mm:ss -നു',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY, A h:mm -നു',
    LLLL : 'dddd, D MMMM YYYY, A h:mm -നു'
},
calendar : {
    sameDay : '[ഇന്ന്] LT',
    nextDay : '[നാളെ] LT',
    nextWeek : 'dddd, LT',
    lastDay : '[ഇന്നലെ] LT',
    lastWeek : '[കഴിഞ്ഞ] dddd, LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s കഴിഞ്ഞ്',
    past : '%s മുൻപ്',
    s : 'അൽപ നിമിഷങ്ങൾ',
    m : 'ഒരു മിനിറ്റ്',
    mm : '%d മിനിറ്റ്',
    h : 'ഒരു മണിക്കൂർ',
    hh : '%d മണിക്കൂർ',
    d : 'ഒരു ദിവസം',
    dd : '%d ദിവസം',
    M : 'ഒരു മാസം',
    MM : '%d മാസം',
    y : 'ഒരു വർഷം',
    yy : '%d വർഷം'
},
meridiemParse: /രാത്രി|രാവിലെ|ഉച്ച കഴിഞ്ഞ്|വൈകുന്നേരം|രാത്രി/i,
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if ((meridiem === 'രാത്രി' && hour >= 4) ||
            meridiem === 'ഉച്ച കഴിഞ്ഞ്' ||
            meridiem === 'വൈകുന്നേരം') {
        return hour + 12;
    } else {
        return hour;
    }
},
meridiem : function (hour, minute, isLower) {
    if (hour < 4) {
        return 'രാത്രി';
    } else if (hour < 12) {
        return 'രാവിലെ';
    } else if (hour < 17) {
        return 'ഉച്ച കഴിഞ്ഞ്';
    } else if (hour < 20) {
        return 'വൈകുന്നേരം';
    } else {
        return 'രാത്രി';
    }
}

});

return ml;

})));

/***/ }), /* 108 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Marathi [mr] //! author : Harshad Kale : github.com/kalehv //! author : Vivek Athalye : github.com/vnathalye

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var symbolMap = {

'1': '१',
'2': '२',
'3': '३',
'4': '४',
'5': '५',
'6': '६',
'7': '७',
'8': '८',
'9': '९',
'0': '०'

}; var numberMap = {

'१': '1',
'२': '2',
'३': '3',
'४': '4',
'५': '5',
'६': '6',
'७': '7',
'८': '8',
'९': '9',
'०': '0'

};

function relativeTimeMr(number, withoutSuffix, string, isFuture) {

var output = '';
if (withoutSuffix) {
    switch (string) {
        case 's': output = 'काही सेकंद'; break;
        case 'm': output = 'एक मिनिट'; break;
        case 'mm': output = '%d मिनिटे'; break;
        case 'h': output = 'एक तास'; break;
        case 'hh': output = '%d तास'; break;
        case 'd': output = 'एक दिवस'; break;
        case 'dd': output = '%d दिवस'; break;
        case 'M': output = 'एक महिना'; break;
        case 'MM': output = '%d महिने'; break;
        case 'y': output = 'एक वर्ष'; break;
        case 'yy': output = '%d वर्षे'; break;
    }
}
else {
    switch (string) {
        case 's': output = 'काही सेकंदां'; break;
        case 'm': output = 'एका मिनिटा'; break;
        case 'mm': output = '%d मिनिटां'; break;
        case 'h': output = 'एका तासा'; break;
        case 'hh': output = '%d तासां'; break;
        case 'd': output = 'एका दिवसा'; break;
        case 'dd': output = '%d दिवसां'; break;
        case 'M': output = 'एका महिन्या'; break;
        case 'MM': output = '%d महिन्यां'; break;
        case 'y': output = 'एका वर्षा'; break;
        case 'yy': output = '%d वर्षां'; break;
    }
}
return output.replace(/%d/i, number);

}

var mr = moment.defineLocale('mr', {

months : 'जानेवारी_फेब्रुवारी_मार्च_एप्रिल_मे_जून_जुलै_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर'.split('_'),
monthsShort: 'जाने._फेब्रु._मार्च._एप्रि._मे._जून._जुलै._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.'.split('_'),
monthsParseExact : true,
weekdays : 'रविवार_सोमवार_मंगळवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
weekdaysShort : 'रवि_सोम_मंगळ_बुध_गुरू_शुक्र_शनि'.split('_'),
weekdaysMin : 'र_सो_मं_बु_गु_शु_श'.split('_'),
longDateFormat : {
    LT : 'A h:mm वाजता',
    LTS : 'A h:mm:ss वाजता',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY, A h:mm वाजता',
    LLLL : 'dddd, D MMMM YYYY, A h:mm वाजता'
},
calendar : {
    sameDay : '[आज] LT',
    nextDay : '[उद्या] LT',
    nextWeek : 'dddd, LT',
    lastDay : '[काल] LT',
    lastWeek: '[मागील] dddd, LT',
    sameElse : 'L'
},
relativeTime : {
    future: '%sमध्ये',
    past: '%sपूर्वी',
    s: relativeTimeMr,
    m: relativeTimeMr,
    mm: relativeTimeMr,
    h: relativeTimeMr,
    hh: relativeTimeMr,
    d: relativeTimeMr,
    dd: relativeTimeMr,
    M: relativeTimeMr,
    MM: relativeTimeMr,
    y: relativeTimeMr,
    yy: relativeTimeMr
},
preparse: function (string) {
    return string.replace(/[१२३४५६७८९०]/g, function (match) {
        return numberMap[match];
    });
},
postformat: function (string) {
    return string.replace(/\d/g, function (match) {
        return symbolMap[match];
    });
},
meridiemParse: /रात्री|सकाळी|दुपारी|सायंकाळी/,
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === 'रात्री') {
        return hour < 4 ? hour : hour + 12;
    } else if (meridiem === 'सकाळी') {
        return hour;
    } else if (meridiem === 'दुपारी') {
        return hour >= 10 ? hour : hour + 12;
    } else if (meridiem === 'सायंकाळी') {
        return hour + 12;
    }
},
meridiem: function (hour, minute, isLower) {
    if (hour < 4) {
        return 'रात्री';
    } else if (hour < 10) {
        return 'सकाळी';
    } else if (hour < 17) {
        return 'दुपारी';
    } else if (hour < 20) {
        return 'सायंकाळी';
    } else {
        return 'रात्री';
    }
},
week : {
    dow : 0, // Sunday is the first day of the week.
    doy : 6  // The week that contains Jan 1st is the first week of the year.
}

});

return mr;

})));

/***/ }), /* 109 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Malay [ms] //! author : Weldan Jamili : github.com/weldan

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var ms = moment.defineLocale('ms', {

months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
longDateFormat : {
    LT : 'HH.mm',
    LTS : 'HH.mm.ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY [pukul] HH.mm',
    LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
},
meridiemParse: /pagi|tengahari|petang|malam/,
meridiemHour: function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === 'pagi') {
        return hour;
    } else if (meridiem === 'tengahari') {
        return hour >= 11 ? hour : hour + 12;
    } else if (meridiem === 'petang' || meridiem === 'malam') {
        return hour + 12;
    }
},
meridiem : function (hours, minutes, isLower) {
    if (hours < 11) {
        return 'pagi';
    } else if (hours < 15) {
        return 'tengahari';
    } else if (hours < 19) {
        return 'petang';
    } else {
        return 'malam';
    }
},
calendar : {
    sameDay : '[Hari ini pukul] LT',
    nextDay : '[Esok pukul] LT',
    nextWeek : 'dddd [pukul] LT',
    lastDay : '[Kelmarin pukul] LT',
    lastWeek : 'dddd [lepas pukul] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'dalam %s',
    past : '%s yang lepas',
    s : 'beberapa saat',
    m : 'seminit',
    mm : '%d minit',
    h : 'sejam',
    hh : '%d jam',
    d : 'sehari',
    dd : '%d hari',
    M : 'sebulan',
    MM : '%d bulan',
    y : 'setahun',
    yy : '%d tahun'
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return ms;

})));

/***/ }), /* 110 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Malay [ms-my] //! note : DEPRECATED, the correct one is [ms] //! author : Weldan Jamili : github.com/weldan

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var msMy = moment.defineLocale('ms-my', {

months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
longDateFormat : {
    LT : 'HH.mm',
    LTS : 'HH.mm.ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY [pukul] HH.mm',
    LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
},
meridiemParse: /pagi|tengahari|petang|malam/,
meridiemHour: function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === 'pagi') {
        return hour;
    } else if (meridiem === 'tengahari') {
        return hour >= 11 ? hour : hour + 12;
    } else if (meridiem === 'petang' || meridiem === 'malam') {
        return hour + 12;
    }
},
meridiem : function (hours, minutes, isLower) {
    if (hours < 11) {
        return 'pagi';
    } else if (hours < 15) {
        return 'tengahari';
    } else if (hours < 19) {
        return 'petang';
    } else {
        return 'malam';
    }
},
calendar : {
    sameDay : '[Hari ini pukul] LT',
    nextDay : '[Esok pukul] LT',
    nextWeek : 'dddd [pukul] LT',
    lastDay : '[Kelmarin pukul] LT',
    lastWeek : 'dddd [lepas pukul] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'dalam %s',
    past : '%s yang lepas',
    s : 'beberapa saat',
    m : 'seminit',
    mm : '%d minit',
    h : 'sejam',
    hh : '%d jam',
    d : 'sehari',
    dd : '%d hari',
    M : 'sebulan',
    MM : '%d bulan',
    y : 'setahun',
    yy : '%d tahun'
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return msMy;

})));

/***/ }), /* 111 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Burmese [my] //! author : Squar team, mysquar.com //! author : David Rossellat : github.com/gholadr //! author : Tin Aung Lin : github.com/thanyawzinmin

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var symbolMap = {

'1': '၁',
'2': '၂',
'3': '၃',
'4': '၄',
'5': '၅',
'6': '၆',
'7': '၇',
'8': '၈',
'9': '၉',
'0': '၀'

}; var numberMap = {

'၁': '1',
'၂': '2',
'၃': '3',
'၄': '4',
'၅': '5',
'၆': '6',
'၇': '7',
'၈': '8',
'၉': '9',
'၀': '0'

};

var my = moment.defineLocale('my', {

months: 'ဇန်နဝါရီ_ဖေဖော်ဝါရီ_မတ်_ဧပြီ_မေ_ဇွန်_ဇူလိုင်_သြဂုတ်_စက်တင်ဘာ_အောက်တိုဘာ_နိုဝင်ဘာ_ဒီဇင်ဘာ'.split('_'),
monthsShort: 'ဇန်_ဖေ_မတ်_ပြီ_မေ_ဇွန်_လိုင်_သြ_စက်_အောက်_နို_ဒီ'.split('_'),
weekdays: 'တနင်္ဂနွေ_တနင်္လာ_အင်္ဂါ_ဗုဒ္ဓဟူး_ကြာသပတေး_သောကြာ_စနေ'.split('_'),
weekdaysShort: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
weekdaysMin: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),

longDateFormat: {
    LT: 'HH:mm',
    LTS: 'HH:mm:ss',
    L: 'DD/MM/YYYY',
    LL: 'D MMMM YYYY',
    LLL: 'D MMMM YYYY HH:mm',
    LLLL: 'dddd D MMMM YYYY HH:mm'
},
calendar: {
    sameDay: '[ယနေ.] LT [မှာ]',
    nextDay: '[မနက်ဖြန်] LT [မှာ]',
    nextWeek: 'dddd LT [မှာ]',
    lastDay: '[မနေ.က] LT [မှာ]',
    lastWeek: '[ပြီးခဲ့သော] dddd LT [မှာ]',
    sameElse: 'L'
},
relativeTime: {
    future: 'လာမည့် %s မှာ',
    past: 'လွန်ခဲ့သော %s က',
    s: 'စက္ကန်.အနည်းငယ်',
    m: 'တစ်မိနစ်',
    mm: '%d မိနစ်',
    h: 'တစ်နာရီ',
    hh: '%d နာရီ',
    d: 'တစ်ရက်',
    dd: '%d ရက်',
    M: 'တစ်လ',
    MM: '%d လ',
    y: 'တစ်နှစ်',
    yy: '%d နှစ်'
},
preparse: function (string) {
    return string.replace(/[၁၂၃၄၅၆၇၈၉၀]/g, function (match) {
        return numberMap[match];
    });
},
postformat: function (string) {
    return string.replace(/\d/g, function (match) {
        return symbolMap[match];
    });
},
week: {
    dow: 1, // Monday is the first day of the week.
    doy: 4 // The week that contains Jan 1st is the first week of the year.
}

});

return my;

})));

/***/ }), /* 112 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Norwegian Bokmål [nb] //! authors : Espen Hovlandsdal : github.com/rexxars //! Sigurd Gartmann : github.com/sigurdga

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var nb = moment.defineLocale('nb', {

months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
monthsShort : 'jan._feb._mars_april_mai_juni_juli_aug._sep._okt._nov._des.'.split('_'),
monthsParseExact : true,
weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
weekdaysShort : 'sø._ma._ti._on._to._fr._lø.'.split('_'),
weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D. MMMM YYYY',
    LLL : 'D. MMMM YYYY [kl.] HH:mm',
    LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'
},
calendar : {
    sameDay: '[i dag kl.] LT',
    nextDay: '[i morgen kl.] LT',
    nextWeek: 'dddd [kl.] LT',
    lastDay: '[i går kl.] LT',
    lastWeek: '[forrige] dddd [kl.] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'om %s',
    past : '%s siden',
    s : 'noen sekunder',
    m : 'ett minutt',
    mm : '%d minutter',
    h : 'en time',
    hh : '%d timer',
    d : 'en dag',
    dd : '%d dager',
    M : 'en måned',
    MM : '%d måneder',
    y : 'ett år',
    yy : '%d år'
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return nb;

})));

/***/ }), /* 113 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Nepalese [ne] //! author : suvash : github.com/suvash

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var symbolMap = {

'1': '१',
'2': '२',
'3': '३',
'4': '४',
'5': '५',
'6': '६',
'7': '७',
'8': '८',
'9': '९',
'0': '०'

}; var numberMap = {

'१': '1',
'२': '2',
'३': '3',
'४': '4',
'५': '5',
'६': '6',
'७': '7',
'८': '8',
'९': '9',
'०': '0'

};

var ne = moment.defineLocale('ne', {

months : 'जनवरी_फेब्रुवरी_मार्च_अप्रिल_मई_जुन_जुलाई_अगष्ट_सेप्टेम्बर_अक्टोबर_नोभेम्बर_डिसेम्बर'.split('_'),
monthsShort : 'जन._फेब्रु._मार्च_अप्रि._मई_जुन_जुलाई._अग._सेप्ट._अक्टो._नोभे._डिसे.'.split('_'),
monthsParseExact : true,
weekdays : 'आइतबार_सोमबार_मङ्गलबार_बुधबार_बिहिबार_शुक्रबार_शनिबार'.split('_'),
weekdaysShort : 'आइत._सोम._मङ्गल._बुध._बिहि._शुक्र._शनि.'.split('_'),
weekdaysMin : 'आ._सो._मं._बु._बि._शु._श.'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'Aको h:mm बजे',
    LTS : 'Aको h:mm:ss बजे',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY, Aको h:mm बजे',
    LLLL : 'dddd, D MMMM YYYY, Aको h:mm बजे'
},
preparse: function (string) {
    return string.replace(/[१२३४५६७८९०]/g, function (match) {
        return numberMap[match];
    });
},
postformat: function (string) {
    return string.replace(/\d/g, function (match) {
        return symbolMap[match];
    });
},
meridiemParse: /राति|बिहान|दिउँसो|साँझ/,
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === 'राति') {
        return hour < 4 ? hour : hour + 12;
    } else if (meridiem === 'बिहान') {
        return hour;
    } else if (meridiem === 'दिउँसो') {
        return hour >= 10 ? hour : hour + 12;
    } else if (meridiem === 'साँझ') {
        return hour + 12;
    }
},
meridiem : function (hour, minute, isLower) {
    if (hour < 3) {
        return 'राति';
    } else if (hour < 12) {
        return 'बिहान';
    } else if (hour < 16) {
        return 'दिउँसो';
    } else if (hour < 20) {
        return 'साँझ';
    } else {
        return 'राति';
    }
},
calendar : {
    sameDay : '[आज] LT',
    nextDay : '[भोलि] LT',
    nextWeek : '[आउँदो] dddd[,] LT',
    lastDay : '[हिजो] LT',
    lastWeek : '[गएको] dddd[,] LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%sमा',
    past : '%s अगाडि',
    s : 'केही क्षण',
    m : 'एक मिनेट',
    mm : '%d मिनेट',
    h : 'एक घण्टा',
    hh : '%d घण्टा',
    d : 'एक दिन',
    dd : '%d दिन',
    M : 'एक महिना',
    MM : '%d महिना',
    y : 'एक बर्ष',
    yy : '%d बर्ष'
},
week : {
    dow : 0, // Sunday is the first day of the week.
    doy : 6  // The week that contains Jan 1st is the first week of the year.
}

});

return ne;

})));

/***/ }), /* 114 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Dutch [nl] //! author : Joris Röling : github.com/jorisroling //! author : Jacob Middag : github.com/middagj

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var monthsShortWithDots = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'); var monthsShortWithoutDots = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');

var monthsParse = [/^jan/i, /^feb/i, /^maart|mrt.?$/i, /^apr/i, /^mei$/i, /^jun?$/i, /^jul?$/i, /^aug/i, /^sep/i, /^okt/i, /^nov/i, /^dec/i]; var monthsRegex = /^(januari|februari|maart|april|mei|april|ju[nl]i|augustus|september|oktober|november|december|jan.?|feb.?|mrt.?|apr.?|ju.?|aug.?|sep.?|okt.?|nov.?|dec.?)/i;

var nl = moment.defineLocale('nl', {

months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
monthsShort : function (m, format) {
    if (!m) {
        return monthsShortWithDots;
    } else if (/-MMM-/.test(format)) {
        return monthsShortWithoutDots[m.month()];
    } else {
        return monthsShortWithDots[m.month()];
    }
},

monthsRegex: monthsRegex,
monthsShortRegex: monthsRegex,
monthsStrictRegex: /^(januari|februari|maart|mei|ju[nl]i|april|augustus|september|oktober|november|december)/i,
monthsShortStrictRegex: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,

monthsParse : monthsParse,
longMonthsParse : monthsParse,
shortMonthsParse : monthsParse,

weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'),
weekdaysMin : 'Zo_Ma_Di_Wo_Do_Vr_Za'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD-MM-YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
calendar : {
    sameDay: '[vandaag om] LT',
    nextDay: '[morgen om] LT',
    nextWeek: 'dddd [om] LT',
    lastDay: '[gisteren om] LT',
    lastWeek: '[afgelopen] dddd [om] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'over %s',
    past : '%s geleden',
    s : 'een paar seconden',
    m : 'één minuut',
    mm : '%d minuten',
    h : 'één uur',
    hh : '%d uur',
    d : 'één dag',
    dd : '%d dagen',
    M : 'één maand',
    MM : '%d maanden',
    y : 'één jaar',
    yy : '%d jaar'
},
dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
ordinal : function (number) {
    return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return nl;

})));

/***/ }), /* 115 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Dutch (Belgium) [nl-be] //! author : Joris Röling : github.com/jorisroling //! author : Jacob Middag : github.com/middagj

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var monthsShortWithDots = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'); var monthsShortWithoutDots = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');

var monthsParse = [/^jan/i, /^feb/i, /^maart|mrt.?$/i, /^apr/i, /^mei$/i, /^jun?$/i, /^jul?$/i, /^aug/i, /^sep/i, /^okt/i, /^nov/i, /^dec/i]; var monthsRegex = /^(januari|februari|maart|april|mei|april|ju[nl]i|augustus|september|oktober|november|december|jan.?|feb.?|mrt.?|apr.?|ju.?|aug.?|sep.?|okt.?|nov.?|dec.?)/i;

var nlBe = moment.defineLocale('nl-be', {

months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
monthsShort : function (m, format) {
    if (!m) {
        return monthsShortWithDots;
    } else if (/-MMM-/.test(format)) {
        return monthsShortWithoutDots[m.month()];
    } else {
        return monthsShortWithDots[m.month()];
    }
},

monthsRegex: monthsRegex,
monthsShortRegex: monthsRegex,
monthsStrictRegex: /^(januari|februari|maart|mei|ju[nl]i|april|augustus|september|oktober|november|december)/i,
monthsShortStrictRegex: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,

monthsParse : monthsParse,
longMonthsParse : monthsParse,
shortMonthsParse : monthsParse,

weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'),
weekdaysMin : 'Zo_Ma_Di_Wo_Do_Vr_Za'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
calendar : {
    sameDay: '[vandaag om] LT',
    nextDay: '[morgen om] LT',
    nextWeek: 'dddd [om] LT',
    lastDay: '[gisteren om] LT',
    lastWeek: '[afgelopen] dddd [om] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'over %s',
    past : '%s geleden',
    s : 'een paar seconden',
    m : 'één minuut',
    mm : '%d minuten',
    h : 'één uur',
    hh : '%d uur',
    d : 'één dag',
    dd : '%d dagen',
    M : 'één maand',
    MM : '%d maanden',
    y : 'één jaar',
    yy : '%d jaar'
},
dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
ordinal : function (number) {
    return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return nlBe;

})));

/***/ }), /* 116 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Nynorsk [nn] //! author : github.com/mechuwind

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var nn = moment.defineLocale('nn', {

months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
weekdays : 'sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag'.split('_'),
weekdaysShort : 'sun_mån_tys_ons_tor_fre_lau'.split('_'),
weekdaysMin : 'su_må_ty_on_to_fr_lø'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D. MMMM YYYY',
    LLL : 'D. MMMM YYYY [kl.] H:mm',
    LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'
},
calendar : {
    sameDay: '[I dag klokka] LT',
    nextDay: '[I morgon klokka] LT',
    nextWeek: 'dddd [klokka] LT',
    lastDay: '[I går klokka] LT',
    lastWeek: '[Føregåande] dddd [klokka] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'om %s',
    past : '%s sidan',
    s : 'nokre sekund',
    m : 'eit minutt',
    mm : '%d minutt',
    h : 'ein time',
    hh : '%d timar',
    d : 'ein dag',
    dd : '%d dagar',
    M : 'ein månad',
    MM : '%d månader',
    y : 'eit år',
    yy : '%d år'
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return nn;

})));

/***/ }), /* 117 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Punjabi (India) [pa-in] //! author : Harpreet Singh : github.com/harpreetkhalsagtbit

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var symbolMap = {

'1': '੧',
'2': '੨',
'3': '੩',
'4': '੪',
'5': '੫',
'6': '੬',
'7': '੭',
'8': '੮',
'9': '੯',
'0': '੦'

}; var numberMap = {

'੧': '1',
'੨': '2',
'੩': '3',
'੪': '4',
'੫': '5',
'੬': '6',
'੭': '7',
'੮': '8',
'੯': '9',
'੦': '0'

};

var paIn = moment.defineLocale('pa-in', {

// There are months name as per Nanakshahi Calender but they are not used as rigidly in modern Punjabi.
months : 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split('_'),
monthsShort : 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split('_'),
weekdays : 'ਐਤਵਾਰ_ਸੋਮਵਾਰ_ਮੰਗਲਵਾਰ_ਬੁਧਵਾਰ_ਵੀਰਵਾਰ_ਸ਼ੁੱਕਰਵਾਰ_ਸ਼ਨੀਚਰਵਾਰ'.split('_'),
weekdaysShort : 'ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ'.split('_'),
weekdaysMin : 'ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ'.split('_'),
longDateFormat : {
    LT : 'A h:mm ਵਜੇ',
    LTS : 'A h:mm:ss ਵਜੇ',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY, A h:mm ਵਜੇ',
    LLLL : 'dddd, D MMMM YYYY, A h:mm ਵਜੇ'
},
calendar : {
    sameDay : '[ਅਜ] LT',
    nextDay : '[ਕਲ] LT',
    nextWeek : 'dddd, LT',
    lastDay : '[ਕਲ] LT',
    lastWeek : '[ਪਿਛਲੇ] dddd, LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s ਵਿੱਚ',
    past : '%s ਪਿਛਲੇ',
    s : 'ਕੁਝ ਸਕਿੰਟ',
    m : 'ਇਕ ਮਿੰਟ',
    mm : '%d ਮਿੰਟ',
    h : 'ਇੱਕ ਘੰਟਾ',
    hh : '%d ਘੰਟੇ',
    d : 'ਇੱਕ ਦਿਨ',
    dd : '%d ਦਿਨ',
    M : 'ਇੱਕ ਮਹੀਨਾ',
    MM : '%d ਮਹੀਨੇ',
    y : 'ਇੱਕ ਸਾਲ',
    yy : '%d ਸਾਲ'
},
preparse: function (string) {
    return string.replace(/[੧੨੩੪੫੬੭੮੯੦]/g, function (match) {
        return numberMap[match];
    });
},
postformat: function (string) {
    return string.replace(/\d/g, function (match) {
        return symbolMap[match];
    });
},
// Punjabi notation for meridiems are quite fuzzy in practice. While there exists
// a rigid notion of a 'Pahar' it is not used as rigidly in modern Punjabi.
meridiemParse: /ਰਾਤ|ਸਵੇਰ|ਦੁਪਹਿਰ|ਸ਼ਾਮ/,
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === 'ਰਾਤ') {
        return hour < 4 ? hour : hour + 12;
    } else if (meridiem === 'ਸਵੇਰ') {
        return hour;
    } else if (meridiem === 'ਦੁਪਹਿਰ') {
        return hour >= 10 ? hour : hour + 12;
    } else if (meridiem === 'ਸ਼ਾਮ') {
        return hour + 12;
    }
},
meridiem : function (hour, minute, isLower) {
    if (hour < 4) {
        return 'ਰਾਤ';
    } else if (hour < 10) {
        return 'ਸਵੇਰ';
    } else if (hour < 17) {
        return 'ਦੁਪਹਿਰ';
    } else if (hour < 20) {
        return 'ਸ਼ਾਮ';
    } else {
        return 'ਰਾਤ';
    }
},
week : {
    dow : 0, // Sunday is the first day of the week.
    doy : 6  // The week that contains Jan 1st is the first week of the year.
}

});

return paIn;

})));

/***/ }), /* 118 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Polish [pl] //! author : Rafal Hirsz : github.com/evoL

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var monthsNominative = 'styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień'.split('_'); var monthsSubjective = 'stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia'.split('_'); function plural(n) {

return (n % 10 < 5) && (n % 10 > 1) && ((~~(n / 10) % 10) !== 1);

} function translate(number, withoutSuffix, key) {

var result = number + ' ';
switch (key) {
    case 'm':
        return withoutSuffix ? 'minuta' : 'minutę';
    case 'mm':
        return result + (plural(number) ? 'minuty' : 'minut');
    case 'h':
        return withoutSuffix  ? 'godzina'  : 'godzinę';
    case 'hh':
        return result + (plural(number) ? 'godziny' : 'godzin');
    case 'MM':
        return result + (plural(number) ? 'miesiące' : 'miesięcy');
    case 'yy':
        return result + (plural(number) ? 'lata' : 'lat');
}

}

var pl = moment.defineLocale('pl', {

months : function (momentToFormat, format) {
    if (!momentToFormat) {
        return monthsNominative;
    } else if (format === '') {
        // Hack: if format empty we know this is used to generate
        // RegExp by moment. Give then back both valid forms of months
        // in RegExp ready format.
        return '(' + monthsSubjective[momentToFormat.month()] + '|' + monthsNominative[momentToFormat.month()] + ')';
    } else if (/D MMMM/.test(format)) {
        return monthsSubjective[momentToFormat.month()];
    } else {
        return monthsNominative[momentToFormat.month()];
    }
},
monthsShort : 'sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru'.split('_'),
weekdays : 'niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota'.split('_'),
weekdaysShort : 'ndz_pon_wt_śr_czw_pt_sob'.split('_'),
weekdaysMin : 'Nd_Pn_Wt_Śr_Cz_Pt_So'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
calendar : {
    sameDay: '[Dziś o] LT',
    nextDay: '[Jutro o] LT',
    nextWeek: '[W] dddd [o] LT',
    lastDay: '[Wczoraj o] LT',
    lastWeek: function () {
        switch (this.day()) {
            case 0:
                return '[W zeszłą niedzielę o] LT';
            case 3:
                return '[W zeszłą środę o] LT';
            case 6:
                return '[W zeszłą sobotę o] LT';
            default:
                return '[W zeszły] dddd [o] LT';
        }
    },
    sameElse: 'L'
},
relativeTime : {
    future : 'za %s',
    past : '%s temu',
    s : 'kilka sekund',
    m : translate,
    mm : translate,
    h : translate,
    hh : translate,
    d : '1 dzień',
    dd : '%d dni',
    M : 'miesiąc',
    MM : translate,
    y : 'rok',
    yy : translate
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return pl;

})));

/***/ }), /* 119 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Portuguese [pt] //! author : Jefferson : github.com/jalex79

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var pt = moment.defineLocale('pt', {

months : 'Janeiro_Fevereiro_Março_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro'.split('_'),
monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
weekdays : 'Domingo_Segunda-Feira_Terça-Feira_Quarta-Feira_Quinta-Feira_Sexta-Feira_Sábado'.split('_'),
weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
weekdaysMin : 'Do_2ª_3ª_4ª_5ª_6ª_Sá'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D [de] MMMM [de] YYYY',
    LLL : 'D [de] MMMM [de] YYYY HH:mm',
    LLLL : 'dddd, D [de] MMMM [de] YYYY HH:mm'
},
calendar : {
    sameDay: '[Hoje às] LT',
    nextDay: '[Amanhã às] LT',
    nextWeek: 'dddd [às] LT',
    lastDay: '[Ontem às] LT',
    lastWeek: function () {
        return (this.day() === 0 || this.day() === 6) ?
            '[Último] dddd [às] LT' : // Saturday + Sunday
            '[Última] dddd [às] LT'; // Monday - Friday
    },
    sameElse: 'L'
},
relativeTime : {
    future : 'em %s',
    past : 'há %s',
    s : 'segundos',
    m : 'um minuto',
    mm : '%d minutos',
    h : 'uma hora',
    hh : '%d horas',
    d : 'um dia',
    dd : '%d dias',
    M : 'um mês',
    MM : '%d meses',
    y : 'um ano',
    yy : '%d anos'
},
dayOfMonthOrdinalParse: /\d{1,2}º/,
ordinal : '%dº',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return pt;

})));

/***/ }), /* 120 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Portuguese (Brazil) [pt-br] //! author : Caio Ribeiro Pereira : github.com/caio-ribeiro-pereira

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var ptBr = moment.defineLocale('pt-br', {

months : 'Janeiro_Fevereiro_Março_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro'.split('_'),
monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
weekdays : 'Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado'.split('_'),
weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
weekdaysMin : 'Do_2ª_3ª_4ª_5ª_6ª_Sá'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D [de] MMMM [de] YYYY',
    LLL : 'D [de] MMMM [de] YYYY [às] HH:mm',
    LLLL : 'dddd, D [de] MMMM [de] YYYY [às] HH:mm'
},
calendar : {
    sameDay: '[Hoje às] LT',
    nextDay: '[Amanhã às] LT',
    nextWeek: 'dddd [às] LT',
    lastDay: '[Ontem às] LT',
    lastWeek: function () {
        return (this.day() === 0 || this.day() === 6) ?
            '[Último] dddd [às] LT' : // Saturday + Sunday
            '[Última] dddd [às] LT'; // Monday - Friday
    },
    sameElse: 'L'
},
relativeTime : {
    future : 'em %s',
    past : '%s atrás',
    s : 'poucos segundos',
    m : 'um minuto',
    mm : '%d minutos',
    h : 'uma hora',
    hh : '%d horas',
    d : 'um dia',
    dd : '%d dias',
    M : 'um mês',
    MM : '%d meses',
    y : 'um ano',
    yy : '%d anos'
},
dayOfMonthOrdinalParse: /\d{1,2}º/,
ordinal : '%dº'

});

return ptBr;

})));

/***/ }), /* 121 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Romanian [ro] //! author : Vlad Gurdiga : github.com/gurdiga //! author : Valentin Agachi : github.com/avaly

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function relativeTimeWithPlural(number, withoutSuffix, key) {

var format = {
        'mm': 'minute',
        'hh': 'ore',
        'dd': 'zile',
        'MM': 'luni',
        'yy': 'ani'
    },
    separator = ' ';
if (number % 100 >= 20 || (number >= 100 && number % 100 === 0)) {
    separator = ' de ';
}
return number + separator + format[key];

}

var ro = moment.defineLocale('ro', {

months : 'ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie'.split('_'),
monthsShort : 'ian._febr._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.'.split('_'),
monthsParseExact: true,
weekdays : 'duminică_luni_marți_miercuri_joi_vineri_sâmbătă'.split('_'),
weekdaysShort : 'Dum_Lun_Mar_Mie_Joi_Vin_Sâm'.split('_'),
weekdaysMin : 'Du_Lu_Ma_Mi_Jo_Vi_Sâ'.split('_'),
longDateFormat : {
    LT : 'H:mm',
    LTS : 'H:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY H:mm',
    LLLL : 'dddd, D MMMM YYYY H:mm'
},
calendar : {
    sameDay: '[azi la] LT',
    nextDay: '[mâine la] LT',
    nextWeek: 'dddd [la] LT',
    lastDay: '[ieri la] LT',
    lastWeek: '[fosta] dddd [la] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'peste %s',
    past : '%s în urmă',
    s : 'câteva secunde',
    m : 'un minut',
    mm : relativeTimeWithPlural,
    h : 'o oră',
    hh : relativeTimeWithPlural,
    d : 'o zi',
    dd : relativeTimeWithPlural,
    M : 'o lună',
    MM : relativeTimeWithPlural,
    y : 'un an',
    yy : relativeTimeWithPlural
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return ro;

})));

/***/ }), /* 122 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Russian [ru] //! author : Viktorminator : github.com/Viktorminator //! Author : Menelion Elensúle : github.com/Oire //! author : Коренберг Марк : github.com/socketpair

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function plural(word, num) {

var forms = word.split('_');
return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);

} function relativeTimeWithPlural(number, withoutSuffix, key) {

var format = {
    'mm': withoutSuffix ? 'минута_минуты_минут' : 'минуту_минуты_минут',
    'hh': 'час_часа_часов',
    'dd': 'день_дня_дней',
    'MM': 'месяц_месяца_месяцев',
    'yy': 'год_года_лет'
};
if (key === 'm') {
    return withoutSuffix ? 'минута' : 'минуту';
}
else {
    return number + ' ' + plural(format[key], +number);
}

} var monthsParse = [/^янв/i, /^фев/i, /^мар/i, /^апр/i, /^ма/i, /^июн/i, /^июл/i, /^авг/i, /^сен/i, /^окт/i, /^ноя/i, /^дек/i];

// new.gramota.ru/spravka/rules/139-prop : § 103 // Сокращения месяцев: new.gramota.ru/spravka/buro/search-answer?s=242637 // CLDR data: www.unicode.org/cldr/charts/28/summary/ru.html#1753 var ru = moment.defineLocale('ru', {

months : {
    format: 'января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря'.split('_'),
    standalone: 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_')
},
monthsShort : {
    // по CLDR именно "июл." и "июн.", но какой смысл менять букву на точку ?
    format: 'янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.'.split('_'),
    standalone: 'янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.'.split('_')
},
weekdays : {
    standalone: 'воскресенье_понедельник_вторник_среда_четверг_пятница_суббота'.split('_'),
    format: 'воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу'.split('_'),
    isFormat: /\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?\] ?dddd/
},
weekdaysShort : 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
weekdaysMin : 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
monthsParse : monthsParse,
longMonthsParse : monthsParse,
shortMonthsParse : monthsParse,

// полные названия с падежами, по три буквы, для некоторых, по 4 буквы, сокращения с точкой и без точки
monthsRegex: /^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,

// копия предыдущего
monthsShortRegex: /^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,

// полные названия с падежами
monthsStrictRegex: /^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,

// Выражение, которое соотвествует только сокращённым формам
monthsShortStrictRegex: /^(янв\.|февр?\.|мар[т.]|апр\.|ма[яй]|июн[ья.]|июл[ья.]|авг\.|сент?\.|окт\.|нояб?\.|дек\.)/i,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D MMMM YYYY г.',
    LLL : 'D MMMM YYYY г., HH:mm',
    LLLL : 'dddd, D MMMM YYYY г., HH:mm'
},
calendar : {
    sameDay: '[Сегодня в] LT',
    nextDay: '[Завтра в] LT',
    lastDay: '[Вчера в] LT',
    nextWeek: function (now) {
        if (now.week() !== this.week()) {
            switch (this.day()) {
                case 0:
                    return '[В следующее] dddd [в] LT';
                case 1:
                case 2:
                case 4:
                    return '[В следующий] dddd [в] LT';
                case 3:
                case 5:
                case 6:
                    return '[В следующую] dddd [в] LT';
            }
        } else {
            if (this.day() === 2) {
                return '[Во] dddd [в] LT';
            } else {
                return '[В] dddd [в] LT';
            }
        }
    },
    lastWeek: function (now) {
        if (now.week() !== this.week()) {
            switch (this.day()) {
                case 0:
                    return '[В прошлое] dddd [в] LT';
                case 1:
                case 2:
                case 4:
                    return '[В прошлый] dddd [в] LT';
                case 3:
                case 5:
                case 6:
                    return '[В прошлую] dddd [в] LT';
            }
        } else {
            if (this.day() === 2) {
                return '[Во] dddd [в] LT';
            } else {
                return '[В] dddd [в] LT';
            }
        }
    },
    sameElse: 'L'
},
relativeTime : {
    future : 'через %s',
    past : '%s назад',
    s : 'несколько секунд',
    m : relativeTimeWithPlural,
    mm : relativeTimeWithPlural,
    h : 'час',
    hh : relativeTimeWithPlural,
    d : 'день',
    dd : relativeTimeWithPlural,
    M : 'месяц',
    MM : relativeTimeWithPlural,
    y : 'год',
    yy : relativeTimeWithPlural
},
meridiemParse: /ночи|утра|дня|вечера/i,
isPM : function (input) {
    return /^(дня|вечера)$/.test(input);
},
meridiem : function (hour, minute, isLower) {
    if (hour < 4) {
        return 'ночи';
    } else if (hour < 12) {
        return 'утра';
    } else if (hour < 17) {
        return 'дня';
    } else {
        return 'вечера';
    }
},
dayOfMonthOrdinalParse: /\d{1,2}-(й|го|я)/,
ordinal: function (number, period) {
    switch (period) {
        case 'M':
        case 'd':
        case 'DDD':
            return number + '-й';
        case 'D':
            return number + '-го';
        case 'w':
        case 'W':
            return number + '-я';
        default:
            return number;
    }
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return ru;

})));

/***/ }), /* 123 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Sindhi [sd] //! author : Narain Sagar : github.com/narainsagar

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var months = [

'جنوري',
'فيبروري',
'مارچ',
'اپريل',
'مئي',
'جون',
'جولاءِ',
'آگسٽ',
'سيپٽمبر',
'آڪٽوبر',
'نومبر',
'ڊسمبر'

]; var days = [

'آچر',
'سومر',
'اڱارو',
'اربع',
'خميس',
'جمع',
'ڇنڇر'

];

var sd = moment.defineLocale('sd', {

months : months,
monthsShort : months,
weekdays : days,
weekdaysShort : days,
weekdaysMin : days,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd، D MMMM YYYY HH:mm'
},
meridiemParse: /صبح|شام/,
isPM : function (input) {
    return 'شام' === input;
},
meridiem : function (hour, minute, isLower) {
    if (hour < 12) {
        return 'صبح';
    }
    return 'شام';
},
calendar : {
    sameDay : '[اڄ] LT',
    nextDay : '[سڀاڻي] LT',
    nextWeek : 'dddd [اڳين هفتي تي] LT',
    lastDay : '[ڪالهه] LT',
    lastWeek : '[گزريل هفتي] dddd [تي] LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s پوء',
    past : '%s اڳ',
    s : 'چند سيڪنڊ',
    m : 'هڪ منٽ',
    mm : '%d منٽ',
    h : 'هڪ ڪلاڪ',
    hh : '%d ڪلاڪ',
    d : 'هڪ ڏينهن',
    dd : '%d ڏينهن',
    M : 'هڪ مهينو',
    MM : '%d مهينا',
    y : 'هڪ سال',
    yy : '%d سال'
},
preparse: function (string) {
    return string.replace(/،/g, ',');
},
postformat: function (string) {
    return string.replace(/,/g, '،');
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return sd;

})));

/***/ }), /* 124 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Northern Sami [se] //! authors : Bård Rolstad Henriksen : github.com/karamell

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var se = moment.defineLocale('se', {

months : 'ođđajagemánnu_guovvamánnu_njukčamánnu_cuoŋománnu_miessemánnu_geassemánnu_suoidnemánnu_borgemánnu_čakčamánnu_golggotmánnu_skábmamánnu_juovlamánnu'.split('_'),
monthsShort : 'ođđj_guov_njuk_cuo_mies_geas_suoi_borg_čakč_golg_skáb_juov'.split('_'),
weekdays : 'sotnabeaivi_vuossárga_maŋŋebárga_gaskavahkku_duorastat_bearjadat_lávvardat'.split('_'),
weekdaysShort : 'sotn_vuos_maŋ_gask_duor_bear_láv'.split('_'),
weekdaysMin : 's_v_m_g_d_b_L'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'MMMM D. [b.] YYYY',
    LLL : 'MMMM D. [b.] YYYY [ti.] HH:mm',
    LLLL : 'dddd, MMMM D. [b.] YYYY [ti.] HH:mm'
},
calendar : {
    sameDay: '[otne ti] LT',
    nextDay: '[ihttin ti] LT',
    nextWeek: 'dddd [ti] LT',
    lastDay: '[ikte ti] LT',
    lastWeek: '[ovddit] dddd [ti] LT',
    sameElse: 'L'
},
relativeTime : {
    future : '%s geažes',
    past : 'maŋit %s',
    s : 'moadde sekunddat',
    m : 'okta minuhta',
    mm : '%d minuhtat',
    h : 'okta diimmu',
    hh : '%d diimmut',
    d : 'okta beaivi',
    dd : '%d beaivvit',
    M : 'okta mánnu',
    MM : '%d mánut',
    y : 'okta jahki',
    yy : '%d jagit'
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return se;

})));

/***/ }), /* 125 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Sinhalese [si] //! author : Sampath Sitinamaluwa : github.com/sampathsris

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

/*jshint -W100*/ var si = moment.defineLocale('si', {

months : 'ජනවාරි_පෙබරවාරි_මාර්තු_අප්‍රේල්_මැයි_ජූනි_ජූලි_අගෝස්තු_සැප්තැම්බර්_ඔක්තෝබර්_නොවැම්බර්_දෙසැම්බර්'.split('_'),
monthsShort : 'ජන_පෙබ_මාර්_අප්_මැයි_ජූනි_ජූලි_අගෝ_සැප්_ඔක්_නොවැ_දෙසැ'.split('_'),
weekdays : 'ඉරිදා_සඳුදා_අඟහරුවාදා_බදාදා_බ්‍රහස්පතින්දා_සිකුරාදා_සෙනසුරාදා'.split('_'),
weekdaysShort : 'ඉරි_සඳු_අඟ_බදා_බ්‍රහ_සිකු_සෙන'.split('_'),
weekdaysMin : 'ඉ_ස_අ_බ_බ්‍ර_සි_සෙ'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'a h:mm',
    LTS : 'a h:mm:ss',
    L : 'YYYY/MM/DD',
    LL : 'YYYY MMMM D',
    LLL : 'YYYY MMMM D, a h:mm',
    LLLL : 'YYYY MMMM D [වැනි] dddd, a h:mm:ss'
},
calendar : {
    sameDay : '[අද] LT[ට]',
    nextDay : '[හෙට] LT[ට]',
    nextWeek : 'dddd LT[ට]',
    lastDay : '[ඊයේ] LT[ට]',
    lastWeek : '[පසුගිය] dddd LT[ට]',
    sameElse : 'L'
},
relativeTime : {
    future : '%sකින්',
    past : '%sකට පෙර',
    s : 'තත්පර කිහිපය',
    m : 'මිනිත්තුව',
    mm : 'මිනිත්තු %d',
    h : 'පැය',
    hh : 'පැය %d',
    d : 'දිනය',
    dd : 'දින %d',
    M : 'මාසය',
    MM : 'මාස %d',
    y : 'වසර',
    yy : 'වසර %d'
},
dayOfMonthOrdinalParse: /\d{1,2} වැනි/,
ordinal : function (number) {
    return number + ' වැනි';
},
meridiemParse : /පෙර වරු|පස් වරු|පෙ.ව|ප.ව./,
isPM : function (input) {
    return input === 'ප.ව.' || input === 'පස් වරු';
},
meridiem : function (hours, minutes, isLower) {
    if (hours > 11) {
        return isLower ? 'ප.ව.' : 'පස් වරු';
    } else {
        return isLower ? 'පෙ.ව.' : 'පෙර වරු';
    }
}

});

return si;

})));

/***/ }), /* 126 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Slovak [sk] //! author : Martin Minka : github.com/k2s //! based on work of petrbela : github.com/petrbela

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var months = 'január_február_marec_apríl_máj_jún_júl_august_september_október_november_december'.split('_'); var monthsShort = 'jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec'.split('_'); function plural(n) {

return (n > 1) && (n < 5);

} function translate(number, withoutSuffix, key, isFuture) {

var result = number + ' ';
switch (key) {
    case 's':  // a few seconds / in a few seconds / a few seconds ago
        return (withoutSuffix || isFuture) ? 'pár sekúnd' : 'pár sekundami';
    case 'm':  // a minute / in a minute / a minute ago
        return withoutSuffix ? 'minúta' : (isFuture ? 'minútu' : 'minútou');
    case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
        if (withoutSuffix || isFuture) {
            return result + (plural(number) ? 'minúty' : 'minút');
        } else {
            return result + 'minútami';
        }
        break;
    case 'h':  // an hour / in an hour / an hour ago
        return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
    case 'hh': // 9 hours / in 9 hours / 9 hours ago
        if (withoutSuffix || isFuture) {
            return result + (plural(number) ? 'hodiny' : 'hodín');
        } else {
            return result + 'hodinami';
        }
        break;
    case 'd':  // a day / in a day / a day ago
        return (withoutSuffix || isFuture) ? 'deň' : 'dňom';
    case 'dd': // 9 days / in 9 days / 9 days ago
        if (withoutSuffix || isFuture) {
            return result + (plural(number) ? 'dni' : 'dní');
        } else {
            return result + 'dňami';
        }
        break;
    case 'M':  // a month / in a month / a month ago
        return (withoutSuffix || isFuture) ? 'mesiac' : 'mesiacom';
    case 'MM': // 9 months / in 9 months / 9 months ago
        if (withoutSuffix || isFuture) {
            return result + (plural(number) ? 'mesiace' : 'mesiacov');
        } else {
            return result + 'mesiacmi';
        }
        break;
    case 'y':  // a year / in a year / a year ago
        return (withoutSuffix || isFuture) ? 'rok' : 'rokom';
    case 'yy': // 9 years / in 9 years / 9 years ago
        if (withoutSuffix || isFuture) {
            return result + (plural(number) ? 'roky' : 'rokov');
        } else {
            return result + 'rokmi';
        }
        break;
}

}

var sk = moment.defineLocale('sk', {

months : months,
monthsShort : monthsShort,
weekdays : 'nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota'.split('_'),
weekdaysShort : 'ne_po_ut_st_št_pi_so'.split('_'),
weekdaysMin : 'ne_po_ut_st_št_pi_so'.split('_'),
longDateFormat : {
    LT: 'H:mm',
    LTS : 'H:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D. MMMM YYYY',
    LLL : 'D. MMMM YYYY H:mm',
    LLLL : 'dddd D. MMMM YYYY H:mm'
},
calendar : {
    sameDay: '[dnes o] LT',
    nextDay: '[zajtra o] LT',
    nextWeek: function () {
        switch (this.day()) {
            case 0:
                return '[v nedeľu o] LT';
            case 1:
            case 2:
                return '[v] dddd [o] LT';
            case 3:
                return '[v stredu o] LT';
            case 4:
                return '[vo štvrtok o] LT';
            case 5:
                return '[v piatok o] LT';
            case 6:
                return '[v sobotu o] LT';
        }
    },
    lastDay: '[včera o] LT',
    lastWeek: function () {
        switch (this.day()) {
            case 0:
                return '[minulú nedeľu o] LT';
            case 1:
            case 2:
                return '[minulý] dddd [o] LT';
            case 3:
                return '[minulú stredu o] LT';
            case 4:
            case 5:
                return '[minulý] dddd [o] LT';
            case 6:
                return '[minulú sobotu o] LT';
        }
    },
    sameElse: 'L'
},
relativeTime : {
    future : 'za %s',
    past : 'pred %s',
    s : translate,
    m : translate,
    mm : translate,
    h : translate,
    hh : translate,
    d : translate,
    dd : translate,
    M : translate,
    MM : translate,
    y : translate,
    yy : translate
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return sk;

})));

/***/ }), /* 127 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Slovenian [sl] //! author : Robert Sedovšek : github.com/sedovsek

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function processRelativeTime(number, withoutSuffix, key, isFuture) {

var result = number + ' ';
switch (key) {
    case 's':
        return withoutSuffix || isFuture ? 'nekaj sekund' : 'nekaj sekundami';
    case 'm':
        return withoutSuffix ? 'ena minuta' : 'eno minuto';
    case 'mm':
        if (number === 1) {
            result += withoutSuffix ? 'minuta' : 'minuto';
        } else if (number === 2) {
            result += withoutSuffix || isFuture ? 'minuti' : 'minutama';
        } else if (number < 5) {
            result += withoutSuffix || isFuture ? 'minute' : 'minutami';
        } else {
            result += withoutSuffix || isFuture ? 'minut' : 'minutami';
        }
        return result;
    case 'h':
        return withoutSuffix ? 'ena ura' : 'eno uro';
    case 'hh':
        if (number === 1) {
            result += withoutSuffix ? 'ura' : 'uro';
        } else if (number === 2) {
            result += withoutSuffix || isFuture ? 'uri' : 'urama';
        } else if (number < 5) {
            result += withoutSuffix || isFuture ? 'ure' : 'urami';
        } else {
            result += withoutSuffix || isFuture ? 'ur' : 'urami';
        }
        return result;
    case 'd':
        return withoutSuffix || isFuture ? 'en dan' : 'enim dnem';
    case 'dd':
        if (number === 1) {
            result += withoutSuffix || isFuture ? 'dan' : 'dnem';
        } else if (number === 2) {
            result += withoutSuffix || isFuture ? 'dni' : 'dnevoma';
        } else {
            result += withoutSuffix || isFuture ? 'dni' : 'dnevi';
        }
        return result;
    case 'M':
        return withoutSuffix || isFuture ? 'en mesec' : 'enim mesecem';
    case 'MM':
        if (number === 1) {
            result += withoutSuffix || isFuture ? 'mesec' : 'mesecem';
        } else if (number === 2) {
            result += withoutSuffix || isFuture ? 'meseca' : 'mesecema';
        } else if (number < 5) {
            result += withoutSuffix || isFuture ? 'mesece' : 'meseci';
        } else {
            result += withoutSuffix || isFuture ? 'mesecev' : 'meseci';
        }
        return result;
    case 'y':
        return withoutSuffix || isFuture ? 'eno leto' : 'enim letom';
    case 'yy':
        if (number === 1) {
            result += withoutSuffix || isFuture ? 'leto' : 'letom';
        } else if (number === 2) {
            result += withoutSuffix || isFuture ? 'leti' : 'letoma';
        } else if (number < 5) {
            result += withoutSuffix || isFuture ? 'leta' : 'leti';
        } else {
            result += withoutSuffix || isFuture ? 'let' : 'leti';
        }
        return result;
}

}

var sl = moment.defineLocale('sl', {

months : 'januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december'.split('_'),
monthsShort : 'jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.'.split('_'),
monthsParseExact: true,
weekdays : 'nedelja_ponedeljek_torek_sreda_četrtek_petek_sobota'.split('_'),
weekdaysShort : 'ned._pon._tor._sre._čet._pet._sob.'.split('_'),
weekdaysMin : 'ne_po_to_sr_če_pe_so'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'H:mm',
    LTS : 'H:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D. MMMM YYYY',
    LLL : 'D. MMMM YYYY H:mm',
    LLLL : 'dddd, D. MMMM YYYY H:mm'
},
calendar : {
    sameDay  : '[danes ob] LT',
    nextDay  : '[jutri ob] LT',

    nextWeek : function () {
        switch (this.day()) {
            case 0:
                return '[v] [nedeljo] [ob] LT';
            case 3:
                return '[v] [sredo] [ob] LT';
            case 6:
                return '[v] [soboto] [ob] LT';
            case 1:
            case 2:
            case 4:
            case 5:
                return '[v] dddd [ob] LT';
        }
    },
    lastDay  : '[včeraj ob] LT',
    lastWeek : function () {
        switch (this.day()) {
            case 0:
                return '[prejšnjo] [nedeljo] [ob] LT';
            case 3:
                return '[prejšnjo] [sredo] [ob] LT';
            case 6:
                return '[prejšnjo] [soboto] [ob] LT';
            case 1:
            case 2:
            case 4:
            case 5:
                return '[prejšnji] dddd [ob] LT';
        }
    },
    sameElse : 'L'
},
relativeTime : {
    future : 'čez %s',
    past   : 'pred %s',
    s      : processRelativeTime,
    m      : processRelativeTime,
    mm     : processRelativeTime,
    h      : processRelativeTime,
    hh     : processRelativeTime,
    d      : processRelativeTime,
    dd     : processRelativeTime,
    M      : processRelativeTime,
    MM     : processRelativeTime,
    y      : processRelativeTime,
    yy     : processRelativeTime
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return sl;

})));

/***/ }), /* 128 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Albanian [sq] //! author : Flakërim Ismani : github.com/flakerimi //! author : Menelion Elensúle : github.com/Oire //! author : Oerd Cukalla : github.com/oerd

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var sq = moment.defineLocale('sq', {

months : 'Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor'.split('_'),
monthsShort : 'Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj'.split('_'),
weekdays : 'E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë'.split('_'),
weekdaysShort : 'Die_Hën_Mar_Mër_Enj_Pre_Sht'.split('_'),
weekdaysMin : 'D_H_Ma_Më_E_P_Sh'.split('_'),
weekdaysParseExact : true,
meridiemParse: /PD|MD/,
isPM: function (input) {
    return input.charAt(0) === 'M';
},
meridiem : function (hours, minutes, isLower) {
    return hours < 12 ? 'PD' : 'MD';
},
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
calendar : {
    sameDay : '[Sot në] LT',
    nextDay : '[Nesër në] LT',
    nextWeek : 'dddd [në] LT',
    lastDay : '[Dje në] LT',
    lastWeek : 'dddd [e kaluar në] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'në %s',
    past : '%s më parë',
    s : 'disa sekonda',
    m : 'një minutë',
    mm : '%d minuta',
    h : 'një orë',
    hh : '%d orë',
    d : 'një ditë',
    dd : '%d ditë',
    M : 'një muaj',
    MM : '%d muaj',
    y : 'një vit',
    yy : '%d vite'
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return sq;

})));

/***/ }), /* 129 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Serbian [sr] //! author : Milan Janačković<milanjanackovic@gmail.com> : github.com/milan-j

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var translator = {

words: { //Different grammatical cases
    m: ['jedan minut', 'jedne minute'],
    mm: ['minut', 'minute', 'minuta'],
    h: ['jedan sat', 'jednog sata'],
    hh: ['sat', 'sata', 'sati'],
    dd: ['dan', 'dana', 'dana'],
    MM: ['mesec', 'meseca', 'meseci'],
    yy: ['godina', 'godine', 'godina']
},
correctGrammaticalCase: function (number, wordKey) {
    return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
},
translate: function (number, withoutSuffix, key) {
    var wordKey = translator.words[key];
    if (key.length === 1) {
        return withoutSuffix ? wordKey[0] : wordKey[1];
    } else {
        return number + ' ' + translator.correctGrammaticalCase(number, wordKey);
    }
}

};

var sr = moment.defineLocale('sr', {

months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'),
monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'),
monthsParseExact: true,
weekdays: 'nedelja_ponedeljak_utorak_sreda_četvrtak_petak_subota'.split('_'),
weekdaysShort: 'ned._pon._uto._sre._čet._pet._sub.'.split('_'),
weekdaysMin: 'ne_po_ut_sr_če_pe_su'.split('_'),
weekdaysParseExact : true,
longDateFormat: {
    LT: 'H:mm',
    LTS : 'H:mm:ss',
    L: 'DD.MM.YYYY',
    LL: 'D. MMMM YYYY',
    LLL: 'D. MMMM YYYY H:mm',
    LLLL: 'dddd, D. MMMM YYYY H:mm'
},
calendar: {
    sameDay: '[danas u] LT',
    nextDay: '[sutra u] LT',
    nextWeek: function () {
        switch (this.day()) {
            case 0:
                return '[u] [nedelju] [u] LT';
            case 3:
                return '[u] [sredu] [u] LT';
            case 6:
                return '[u] [subotu] [u] LT';
            case 1:
            case 2:
            case 4:
            case 5:
                return '[u] dddd [u] LT';
        }
    },
    lastDay  : '[juče u] LT',
    lastWeek : function () {
        var lastWeekDays = [
            '[prošle] [nedelje] [u] LT',
            '[prošlog] [ponedeljka] [u] LT',
            '[prošlog] [utorka] [u] LT',
            '[prošle] [srede] [u] LT',
            '[prošlog] [četvrtka] [u] LT',
            '[prošlog] [petka] [u] LT',
            '[prošle] [subote] [u] LT'
        ];
        return lastWeekDays[this.day()];
    },
    sameElse : 'L'
},
relativeTime : {
    future : 'za %s',
    past   : 'pre %s',
    s      : 'nekoliko sekundi',
    m      : translator.translate,
    mm     : translator.translate,
    h      : translator.translate,
    hh     : translator.translate,
    d      : 'dan',
    dd     : translator.translate,
    M      : 'mesec',
    MM     : translator.translate,
    y      : 'godinu',
    yy     : translator.translate
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return sr;

})));

/***/ }), /* 130 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Serbian Cyrillic [sr-cyrl] //! author : Milan Janačković<milanjanackovic@gmail.com> : github.com/milan-j

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var translator = {

words: { //Different grammatical cases
    m: ['један минут', 'једне минуте'],
    mm: ['минут', 'минуте', 'минута'],
    h: ['један сат', 'једног сата'],
    hh: ['сат', 'сата', 'сати'],
    dd: ['дан', 'дана', 'дана'],
    MM: ['месец', 'месеца', 'месеци'],
    yy: ['година', 'године', 'година']
},
correctGrammaticalCase: function (number, wordKey) {
    return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
},
translate: function (number, withoutSuffix, key) {
    var wordKey = translator.words[key];
    if (key.length === 1) {
        return withoutSuffix ? wordKey[0] : wordKey[1];
    } else {
        return number + ' ' + translator.correctGrammaticalCase(number, wordKey);
    }
}

};

var srCyrl = moment.defineLocale('sr-cyrl', {

months: 'јануар_фебруар_март_април_мај_јун_јул_август_септембар_октобар_новембар_децембар'.split('_'),
monthsShort: 'јан._феб._мар._апр._мај_јун_јул_авг._сеп._окт._нов._дец.'.split('_'),
monthsParseExact: true,
weekdays: 'недеља_понедељак_уторак_среда_четвртак_петак_субота'.split('_'),
weekdaysShort: 'нед._пон._уто._сре._чет._пет._суб.'.split('_'),
weekdaysMin: 'не_по_ут_ср_че_пе_су'.split('_'),
weekdaysParseExact : true,
longDateFormat: {
    LT: 'H:mm',
    LTS : 'H:mm:ss',
    L: 'DD.MM.YYYY',
    LL: 'D. MMMM YYYY',
    LLL: 'D. MMMM YYYY H:mm',
    LLLL: 'dddd, D. MMMM YYYY H:mm'
},
calendar: {
    sameDay: '[данас у] LT',
    nextDay: '[сутра у] LT',
    nextWeek: function () {
        switch (this.day()) {
            case 0:
                return '[у] [недељу] [у] LT';
            case 3:
                return '[у] [среду] [у] LT';
            case 6:
                return '[у] [суботу] [у] LT';
            case 1:
            case 2:
            case 4:
            case 5:
                return '[у] dddd [у] LT';
        }
    },
    lastDay  : '[јуче у] LT',
    lastWeek : function () {
        var lastWeekDays = [
            '[прошле] [недеље] [у] LT',
            '[прошлог] [понедељка] [у] LT',
            '[прошлог] [уторка] [у] LT',
            '[прошле] [среде] [у] LT',
            '[прошлог] [четвртка] [у] LT',
            '[прошлог] [петка] [у] LT',
            '[прошле] [суботе] [у] LT'
        ];
        return lastWeekDays[this.day()];
    },
    sameElse : 'L'
},
relativeTime : {
    future : 'за %s',
    past   : 'пре %s',
    s      : 'неколико секунди',
    m      : translator.translate,
    mm     : translator.translate,
    h      : translator.translate,
    hh     : translator.translate,
    d      : 'дан',
    dd     : translator.translate,
    M      : 'месец',
    MM     : translator.translate,
    y      : 'годину',
    yy     : translator.translate
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return srCyrl;

})));

/***/ }), /* 131 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : siSwati [ss] //! author : Nicolai Davies<mail@nicolai.io> : github.com/nicolaidavies

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var ss = moment.defineLocale('ss', {

months : "Bhimbidvwane_Indlovana_Indlov'lenkhulu_Mabasa_Inkhwekhweti_Inhlaba_Kholwane_Ingci_Inyoni_Imphala_Lweti_Ingongoni".split('_'),
monthsShort : 'Bhi_Ina_Inu_Mab_Ink_Inh_Kho_Igc_Iny_Imp_Lwe_Igo'.split('_'),
weekdays : 'Lisontfo_Umsombuluko_Lesibili_Lesitsatfu_Lesine_Lesihlanu_Umgcibelo'.split('_'),
weekdaysShort : 'Lis_Umb_Lsb_Les_Lsi_Lsh_Umg'.split('_'),
weekdaysMin : 'Li_Us_Lb_Lt_Ls_Lh_Ug'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'h:mm A',
    LTS : 'h:mm:ss A',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY h:mm A',
    LLLL : 'dddd, D MMMM YYYY h:mm A'
},
calendar : {
    sameDay : '[Namuhla nga] LT',
    nextDay : '[Kusasa nga] LT',
    nextWeek : 'dddd [nga] LT',
    lastDay : '[Itolo nga] LT',
    lastWeek : 'dddd [leliphelile] [nga] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'nga %s',
    past : 'wenteka nga %s',
    s : 'emizuzwana lomcane',
    m : 'umzuzu',
    mm : '%d emizuzu',
    h : 'lihora',
    hh : '%d emahora',
    d : 'lilanga',
    dd : '%d emalanga',
    M : 'inyanga',
    MM : '%d tinyanga',
    y : 'umnyaka',
    yy : '%d iminyaka'
},
meridiemParse: /ekuseni|emini|entsambama|ebusuku/,
meridiem : function (hours, minutes, isLower) {
    if (hours < 11) {
        return 'ekuseni';
    } else if (hours < 15) {
        return 'emini';
    } else if (hours < 19) {
        return 'entsambama';
    } else {
        return 'ebusuku';
    }
},
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === 'ekuseni') {
        return hour;
    } else if (meridiem === 'emini') {
        return hour >= 11 ? hour : hour + 12;
    } else if (meridiem === 'entsambama' || meridiem === 'ebusuku') {
        if (hour === 0) {
            return 0;
        }
        return hour + 12;
    }
},
dayOfMonthOrdinalParse: /\d{1,2}/,
ordinal : '%d',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return ss;

})));

/***/ }), /* 132 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Swedish [sv] //! author : Jens Alm : github.com/ulmus

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var sv = moment.defineLocale('sv', {

months : 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split('_'),
monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
weekdays : 'söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag'.split('_'),
weekdaysShort : 'sön_mån_tis_ons_tor_fre_lör'.split('_'),
weekdaysMin : 'sö_må_ti_on_to_fr_lö'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'YYYY-MM-DD',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY [kl.] HH:mm',
    LLLL : 'dddd D MMMM YYYY [kl.] HH:mm',
    lll : 'D MMM YYYY HH:mm',
    llll : 'ddd D MMM YYYY HH:mm'
},
calendar : {
    sameDay: '[Idag] LT',
    nextDay: '[Imorgon] LT',
    lastDay: '[Igår] LT',
    nextWeek: '[På] dddd LT',
    lastWeek: '[I] dddd[s] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'om %s',
    past : 'för %s sedan',
    s : 'några sekunder',
    m : 'en minut',
    mm : '%d minuter',
    h : 'en timme',
    hh : '%d timmar',
    d : 'en dag',
    dd : '%d dagar',
    M : 'en månad',
    MM : '%d månader',
    y : 'ett år',
    yy : '%d år'
},
dayOfMonthOrdinalParse: /\d{1,2}(e|a)/,
ordinal : function (number) {
    var b = number % 10,
        output = (~~(number % 100 / 10) === 1) ? 'e' :
        (b === 1) ? 'a' :
        (b === 2) ? 'a' :
        (b === 3) ? 'e' : 'e';
    return number + output;
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return sv;

})));

/***/ }), /* 133 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Swahili [sw] //! author : Fahad Kassim : github.com/fadsel

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var sw = moment.defineLocale('sw', {

months : 'Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba'.split('_'),
monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des'.split('_'),
weekdays : 'Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi'.split('_'),
weekdaysShort : 'Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos'.split('_'),
weekdaysMin : 'J2_J3_J4_J5_Al_Ij_J1'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
calendar : {
    sameDay : '[leo saa] LT',
    nextDay : '[kesho saa] LT',
    nextWeek : '[wiki ijayo] dddd [saat] LT',
    lastDay : '[jana] LT',
    lastWeek : '[wiki iliyopita] dddd [saat] LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s baadaye',
    past : 'tokea %s',
    s : 'hivi punde',
    m : 'dakika moja',
    mm : 'dakika %d',
    h : 'saa limoja',
    hh : 'masaa %d',
    d : 'siku moja',
    dd : 'masiku %d',
    M : 'mwezi mmoja',
    MM : 'miezi %d',
    y : 'mwaka mmoja',
    yy : 'miaka %d'
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return sw;

})));

/***/ }), /* 134 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Tamil [ta] //! author : Arjunkumar Krishnamoorthy : github.com/tk120404

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var symbolMap = {

'1': '௧',
'2': '௨',
'3': '௩',
'4': '௪',
'5': '௫',
'6': '௬',
'7': '௭',
'8': '௮',
'9': '௯',
'0': '௦'

}; var numberMap = {

'௧': '1',
'௨': '2',
'௩': '3',
'௪': '4',
'௫': '5',
'௬': '6',
'௭': '7',
'௮': '8',
'௯': '9',
'௦': '0'

};

var ta = moment.defineLocale('ta', {

months : 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
monthsShort : 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
weekdays : 'ஞாயிற்றுக்கிழமை_திங்கட்கிழமை_செவ்வாய்கிழமை_புதன்கிழமை_வியாழக்கிழமை_வெள்ளிக்கிழமை_சனிக்கிழமை'.split('_'),
weekdaysShort : 'ஞாயிறு_திங்கள்_செவ்வாய்_புதன்_வியாழன்_வெள்ளி_சனி'.split('_'),
weekdaysMin : 'ஞா_தி_செ_பு_வி_வெ_ச'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY, HH:mm',
    LLLL : 'dddd, D MMMM YYYY, HH:mm'
},
calendar : {
    sameDay : '[இன்று] LT',
    nextDay : '[நாளை] LT',
    nextWeek : 'dddd, LT',
    lastDay : '[நேற்று] LT',
    lastWeek : '[கடந்த வாரம்] dddd, LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s இல்',
    past : '%s முன்',
    s : 'ஒரு சில விநாடிகள்',
    m : 'ஒரு நிமிடம்',
    mm : '%d நிமிடங்கள்',
    h : 'ஒரு மணி நேரம்',
    hh : '%d மணி நேரம்',
    d : 'ஒரு நாள்',
    dd : '%d நாட்கள்',
    M : 'ஒரு மாதம்',
    MM : '%d மாதங்கள்',
    y : 'ஒரு வருடம்',
    yy : '%d ஆண்டுகள்'
},
dayOfMonthOrdinalParse: /\d{1,2}வது/,
ordinal : function (number) {
    return number + 'வது';
},
preparse: function (string) {
    return string.replace(/[௧௨௩௪௫௬௭௮௯௦]/g, function (match) {
        return numberMap[match];
    });
},
postformat: function (string) {
    return string.replace(/\d/g, function (match) {
        return symbolMap[match];
    });
},
// refer http://ta.wikipedia.org/s/1er1
meridiemParse: /யாமம்|வைகறை|காலை|நண்பகல்|எற்பாடு|மாலை/,
meridiem : function (hour, minute, isLower) {
    if (hour < 2) {
        return ' யாமம்';
    } else if (hour < 6) {
        return ' வைகறை';  // வைகறை
    } else if (hour < 10) {
        return ' காலை'; // காலை
    } else if (hour < 14) {
        return ' நண்பகல்'; // நண்பகல்
    } else if (hour < 18) {
        return ' எற்பாடு'; // எற்பாடு
    } else if (hour < 22) {
        return ' மாலை'; // மாலை
    } else {
        return ' யாமம்';
    }
},
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === 'யாமம்') {
        return hour < 2 ? hour : hour + 12;
    } else if (meridiem === 'வைகறை' || meridiem === 'காலை') {
        return hour;
    } else if (meridiem === 'நண்பகல்') {
        return hour >= 10 ? hour : hour + 12;
    } else {
        return hour + 12;
    }
},
week : {
    dow : 0, // Sunday is the first day of the week.
    doy : 6  // The week that contains Jan 1st is the first week of the year.
}

});

return ta;

})));

/***/ }), /* 135 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Telugu [te] //! author : Krishna Chaitanya Thota : github.com/kcthota

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var te = moment.defineLocale('te', {

months : 'జనవరి_ఫిబ్రవరి_మార్చి_ఏప్రిల్_మే_జూన్_జూలై_ఆగస్టు_సెప్టెంబర్_అక్టోబర్_నవంబర్_డిసెంబర్'.split('_'),
monthsShort : 'జన._ఫిబ్ర._మార్చి_ఏప్రి._మే_జూన్_జూలై_ఆగ._సెప్._అక్టో._నవ._డిసె.'.split('_'),
monthsParseExact : true,
weekdays : 'ఆదివారం_సోమవారం_మంగళవారం_బుధవారం_గురువారం_శుక్రవారం_శనివారం'.split('_'),
weekdaysShort : 'ఆది_సోమ_మంగళ_బుధ_గురు_శుక్ర_శని'.split('_'),
weekdaysMin : 'ఆ_సో_మం_బు_గు_శు_శ'.split('_'),
longDateFormat : {
    LT : 'A h:mm',
    LTS : 'A h:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY, A h:mm',
    LLLL : 'dddd, D MMMM YYYY, A h:mm'
},
calendar : {
    sameDay : '[నేడు] LT',
    nextDay : '[రేపు] LT',
    nextWeek : 'dddd, LT',
    lastDay : '[నిన్న] LT',
    lastWeek : '[గత] dddd, LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s లో',
    past : '%s క్రితం',
    s : 'కొన్ని క్షణాలు',
    m : 'ఒక నిమిషం',
    mm : '%d నిమిషాలు',
    h : 'ఒక గంట',
    hh : '%d గంటలు',
    d : 'ఒక రోజు',
    dd : '%d రోజులు',
    M : 'ఒక నెల',
    MM : '%d నెలలు',
    y : 'ఒక సంవత్సరం',
    yy : '%d సంవత్సరాలు'
},
dayOfMonthOrdinalParse : /\d{1,2}వ/,
ordinal : '%dవ',
meridiemParse: /రాత్రి|ఉదయం|మధ్యాహ్నం|సాయంత్రం/,
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === 'రాత్రి') {
        return hour < 4 ? hour : hour + 12;
    } else if (meridiem === 'ఉదయం') {
        return hour;
    } else if (meridiem === 'మధ్యాహ్నం') {
        return hour >= 10 ? hour : hour + 12;
    } else if (meridiem === 'సాయంత్రం') {
        return hour + 12;
    }
},
meridiem : function (hour, minute, isLower) {
    if (hour < 4) {
        return 'రాత్రి';
    } else if (hour < 10) {
        return 'ఉదయం';
    } else if (hour < 17) {
        return 'మధ్యాహ్నం';
    } else if (hour < 20) {
        return 'సాయంత్రం';
    } else {
        return 'రాత్రి';
    }
},
week : {
    dow : 0, // Sunday is the first day of the week.
    doy : 6  // The week that contains Jan 1st is the first week of the year.
}

});

return te;

})));

/***/ }), /* 136 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Tetun Dili (East Timor) [tet] //! author : Joshua Brooks : github.com/joshbrooks //! author : Onorio De J. Afonso : github.com/marobo

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var tet = moment.defineLocale('tet', {

months : 'Janeiru_Fevereiru_Marsu_Abril_Maiu_Juniu_Juliu_Augustu_Setembru_Outubru_Novembru_Dezembru'.split('_'),
monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Aug_Set_Out_Nov_Dez'.split('_'),
weekdays : 'Domingu_Segunda_Tersa_Kuarta_Kinta_Sexta_Sabadu'.split('_'),
weekdaysShort : 'Dom_Seg_Ters_Kua_Kint_Sext_Sab'.split('_'),
weekdaysMin : 'Do_Seg_Te_Ku_Ki_Sex_Sa'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
calendar : {
    sameDay: '[Ohin iha] LT',
    nextDay: '[Aban iha] LT',
    nextWeek: 'dddd [iha] LT',
    lastDay: '[Horiseik iha] LT',
    lastWeek: 'dddd [semana kotuk] [iha] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'iha %s',
    past : '%s liuba',
    s : 'minutu balun',
    m : 'minutu ida',
    mm : 'minutus %d',
    h : 'horas ida',
    hh : 'horas %d',
    d : 'loron ida',
    dd : 'loron %d',
    M : 'fulan ida',
    MM : 'fulan %d',
    y : 'tinan ida',
    yy : 'tinan %d'
},
dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
ordinal : function (number) {
    var b = number % 10,
        output = (~~(number % 100 / 10) === 1) ? 'th' :
        (b === 1) ? 'st' :
        (b === 2) ? 'nd' :
        (b === 3) ? 'rd' : 'th';
    return number + output;
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return tet;

})));

/***/ }), /* 137 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Thai [th] //! author : Kridsada Thanabulpong : github.com/sirn

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var th = moment.defineLocale('th', {

months : 'มกราคม_กุมภาพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_กรกฎาคม_สิงหาคม_กันยายน_ตุลาคม_พฤศจิกายน_ธันวาคม'.split('_'),
monthsShort : 'ม.ค._ก.พ._มี.ค._เม.ย._พ.ค._มิ.ย._ก.ค._ส.ค._ก.ย._ต.ค._พ.ย._ธ.ค.'.split('_'),
monthsParseExact: true,
weekdays : 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัสบดี_ศุกร์_เสาร์'.split('_'),
weekdaysShort : 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัส_ศุกร์_เสาร์'.split('_'), // yes, three characters difference
weekdaysMin : 'อา._จ._อ._พ._พฤ._ศ._ส.'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'H:mm',
    LTS : 'H:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY เวลา H:mm',
    LLLL : 'วันddddที่ D MMMM YYYY เวลา H:mm'
},
meridiemParse: /ก่อนเที่ยง|หลังเที่ยง/,
isPM: function (input) {
    return input === 'หลังเที่ยง';
},
meridiem : function (hour, minute, isLower) {
    if (hour < 12) {
        return 'ก่อนเที่ยง';
    } else {
        return 'หลังเที่ยง';
    }
},
calendar : {
    sameDay : '[วันนี้ เวลา] LT',
    nextDay : '[พรุ่งนี้ เวลา] LT',
    nextWeek : 'dddd[หน้า เวลา] LT',
    lastDay : '[เมื่อวานนี้ เวลา] LT',
    lastWeek : '[วัน]dddd[ที่แล้ว เวลา] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'อีก %s',
    past : '%sที่แล้ว',
    s : 'ไม่กี่วินาที',
    m : '1 นาที',
    mm : '%d นาที',
    h : '1 ชั่วโมง',
    hh : '%d ชั่วโมง',
    d : '1 วัน',
    dd : '%d วัน',
    M : '1 เดือน',
    MM : '%d เดือน',
    y : '1 ปี',
    yy : '%d ปี'
}

});

return th;

})));

/***/ }), /* 138 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Tagalog (Philippines) [tl-ph] //! author : Dan Hagman : github.com/hagmandan

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var tlPh = moment.defineLocale('tl-ph', {

months : 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split('_'),
monthsShort : 'Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis'.split('_'),
weekdays : 'Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado'.split('_'),
weekdaysShort : 'Lin_Lun_Mar_Miy_Huw_Biy_Sab'.split('_'),
weekdaysMin : 'Li_Lu_Ma_Mi_Hu_Bi_Sab'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'MM/D/YYYY',
    LL : 'MMMM D, YYYY',
    LLL : 'MMMM D, YYYY HH:mm',
    LLLL : 'dddd, MMMM DD, YYYY HH:mm'
},
calendar : {
    sameDay: 'LT [ngayong araw]',
    nextDay: '[Bukas ng] LT',
    nextWeek: 'LT [sa susunod na] dddd',
    lastDay: 'LT [kahapon]',
    lastWeek: 'LT [noong nakaraang] dddd',
    sameElse: 'L'
},
relativeTime : {
    future : 'sa loob ng %s',
    past : '%s ang nakalipas',
    s : 'ilang segundo',
    m : 'isang minuto',
    mm : '%d minuto',
    h : 'isang oras',
    hh : '%d oras',
    d : 'isang araw',
    dd : '%d araw',
    M : 'isang buwan',
    MM : '%d buwan',
    y : 'isang taon',
    yy : '%d taon'
},
dayOfMonthOrdinalParse: /\d{1,2}/,
ordinal : function (number) {
    return number;
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return tlPh;

})));

/***/ }), /* 139 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Klingon [tlh] //! author : Dominika Kruk : github.com/amaranthrose

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var numbersNouns = 'pagh_wa’_cha’_wej_loS_vagh_jav_Soch_chorgh_Hut'.split('_');

function translateFuture(output) {

var time = output;
time = (output.indexOf('jaj') !== -1) ?
time.slice(0, -3) + 'leS' :
(output.indexOf('jar') !== -1) ?
time.slice(0, -3) + 'waQ' :
(output.indexOf('DIS') !== -1) ?
time.slice(0, -3) + 'nem' :
time + ' pIq';
return time;

}

function translatePast(output) {

var time = output;
time = (output.indexOf('jaj') !== -1) ?
time.slice(0, -3) + 'Hu’' :
(output.indexOf('jar') !== -1) ?
time.slice(0, -3) + 'wen' :
(output.indexOf('DIS') !== -1) ?
time.slice(0, -3) + 'ben' :
time + ' ret';
return time;

}

function translate(number, withoutSuffix, string, isFuture) {

var numberNoun = numberAsNoun(number);
switch (string) {
    case 'mm':
        return numberNoun + ' tup';
    case 'hh':
        return numberNoun + ' rep';
    case 'dd':
        return numberNoun + ' jaj';
    case 'MM':
        return numberNoun + ' jar';
    case 'yy':
        return numberNoun + ' DIS';
}

}

function numberAsNoun(number) {

var hundred = Math.floor((number % 1000) / 100),
ten = Math.floor((number % 100) / 10),
one = number % 10,
word = '';
if (hundred > 0) {
    word += numbersNouns[hundred] + 'vatlh';
}
if (ten > 0) {
    word += ((word !== '') ? ' ' : '') + numbersNouns[ten] + 'maH';
}
if (one > 0) {
    word += ((word !== '') ? ' ' : '') + numbersNouns[one];
}
return (word === '') ? 'pagh' : word;

}

var tlh = moment.defineLocale('tlh', {

months : 'tera’ jar wa’_tera’ jar cha’_tera’ jar wej_tera’ jar loS_tera’ jar vagh_tera’ jar jav_tera’ jar Soch_tera’ jar chorgh_tera’ jar Hut_tera’ jar wa’maH_tera’ jar wa’maH wa’_tera’ jar wa’maH cha’'.split('_'),
monthsShort : 'jar wa’_jar cha’_jar wej_jar loS_jar vagh_jar jav_jar Soch_jar chorgh_jar Hut_jar wa’maH_jar wa’maH wa’_jar wa’maH cha’'.split('_'),
monthsParseExact : true,
weekdays : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
weekdaysShort : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
weekdaysMin : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
calendar : {
    sameDay: '[DaHjaj] LT',
    nextDay: '[wa’leS] LT',
    nextWeek: 'LLL',
    lastDay: '[wa’Hu’] LT',
    lastWeek: 'LLL',
    sameElse: 'L'
},
relativeTime : {
    future : translateFuture,
    past : translatePast,
    s : 'puS lup',
    m : 'wa’ tup',
    mm : translate,
    h : 'wa’ rep',
    hh : translate,
    d : 'wa’ jaj',
    dd : translate,
    M : 'wa’ jar',
    MM : translate,
    y : 'wa’ DIS',
    yy : translate
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return tlh;

})));

/***/ }), /* 140 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Turkish [tr] //! authors : Erhan Gundogan : github.com/erhangundogan, //! Burak Yiğit Kaya: github.com/BYK

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var suffixes = {

1: '\'inci',
5: '\'inci',
8: '\'inci',
70: '\'inci',
80: '\'inci',
2: '\'nci',
7: '\'nci',
20: '\'nci',
50: '\'nci',
3: '\'üncü',
4: '\'üncü',
100: '\'üncü',
6: '\'ncı',
9: '\'uncu',
10: '\'uncu',
30: '\'uncu',
60: '\'ıncı',
90: '\'ıncı'

};

var tr = moment.defineLocale('tr', {

months : 'Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık'.split('_'),
monthsShort : 'Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara'.split('_'),
weekdays : 'Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi'.split('_'),
weekdaysShort : 'Paz_Pts_Sal_Çar_Per_Cum_Cts'.split('_'),
weekdaysMin : 'Pz_Pt_Sa_Ça_Pe_Cu_Ct'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
calendar : {
    sameDay : '[bugün saat] LT',
    nextDay : '[yarın saat] LT',
    nextWeek : '[haftaya] dddd [saat] LT',
    lastDay : '[dün] LT',
    lastWeek : '[geçen hafta] dddd [saat] LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s sonra',
    past : '%s önce',
    s : 'birkaç saniye',
    m : 'bir dakika',
    mm : '%d dakika',
    h : 'bir saat',
    hh : '%d saat',
    d : 'bir gün',
    dd : '%d gün',
    M : 'bir ay',
    MM : '%d ay',
    y : 'bir yıl',
    yy : '%d yıl'
},
dayOfMonthOrdinalParse: /\d{1,2}'(inci|nci|üncü|ncı|uncu|ıncı)/,
ordinal : function (number) {
    if (number === 0) {  // special case for zero
        return number + '\'ıncı';
    }
    var a = number % 10,
        b = number % 100 - a,
        c = number >= 100 ? 100 : null;
    return number + (suffixes[a] || suffixes[b] || suffixes[c]);
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return tr;

})));

/***/ }), /* 141 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Talossan [tzl] //! author : Robin van der Vliet : github.com/robin0van0der0v //! author : Iustì Canun

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

// After the year there should be a slash and the amount of years since December 26, 1979 in Roman numerals. // This is currently too difficult (maybe even impossible) to add. var tzl = moment.defineLocale('tzl', {

months : 'Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar'.split('_'),
monthsShort : 'Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec'.split('_'),
weekdays : 'Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi'.split('_'),
weekdaysShort : 'Súl_Lún_Mai_Már_Xhú_Vié_Sát'.split('_'),
weekdaysMin : 'Sú_Lú_Ma_Má_Xh_Vi_Sá'.split('_'),
longDateFormat : {
    LT : 'HH.mm',
    LTS : 'HH.mm.ss',
    L : 'DD.MM.YYYY',
    LL : 'D. MMMM [dallas] YYYY',
    LLL : 'D. MMMM [dallas] YYYY HH.mm',
    LLLL : 'dddd, [li] D. MMMM [dallas] YYYY HH.mm'
},
meridiemParse: /d\'o|d\'a/i,
isPM : function (input) {
    return 'd\'o' === input.toLowerCase();
},
meridiem : function (hours, minutes, isLower) {
    if (hours > 11) {
        return isLower ? 'd\'o' : 'D\'O';
    } else {
        return isLower ? 'd\'a' : 'D\'A';
    }
},
calendar : {
    sameDay : '[oxhi à] LT',
    nextDay : '[demà à] LT',
    nextWeek : 'dddd [à] LT',
    lastDay : '[ieiri à] LT',
    lastWeek : '[sür el] dddd [lasteu à] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'osprei %s',
    past : 'ja%s',
    s : processRelativeTime,
    m : processRelativeTime,
    mm : processRelativeTime,
    h : processRelativeTime,
    hh : processRelativeTime,
    d : processRelativeTime,
    dd : processRelativeTime,
    M : processRelativeTime,
    MM : processRelativeTime,
    y : processRelativeTime,
    yy : processRelativeTime
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

function processRelativeTime(number, withoutSuffix, key, isFuture) {

var format = {
    's': ['viensas secunds', '\'iensas secunds'],
    'm': ['\'n míut', '\'iens míut'],
    'mm': [number + ' míuts', '' + number + ' míuts'],
    'h': ['\'n þora', '\'iensa þora'],
    'hh': [number + ' þoras', '' + number + ' þoras'],
    'd': ['\'n ziua', '\'iensa ziua'],
    'dd': [number + ' ziuas', '' + number + ' ziuas'],
    'M': ['\'n mes', '\'iens mes'],
    'MM': [number + ' mesen', '' + number + ' mesen'],
    'y': ['\'n ar', '\'iens ar'],
    'yy': [number + ' ars', '' + number + ' ars']
};
return isFuture ? format[key][0] : (withoutSuffix ? format[key][0] : format[key][1]);

}

return tzl;

})));

/***/ }), /* 142 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Central Atlas Tamazight [tzm] //! author : Abdel Said : github.com/abdelsaid

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var tzm = moment.defineLocale('tzm', {

months : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
monthsShort : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
weekdays : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
weekdaysShort : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
weekdaysMin : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS: 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
calendar : {
    sameDay: '[ⴰⵙⴷⵅ ⴴ] LT',
    nextDay: '[ⴰⵙⴽⴰ ⴴ] LT',
    nextWeek: 'dddd [ⴴ] LT',
    lastDay: '[ⴰⵚⴰⵏⵜ ⴴ] LT',
    lastWeek: 'dddd [ⴴ] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ %s',
    past : 'ⵢⴰⵏ %s',
    s : 'ⵉⵎⵉⴽ',
    m : 'ⵎⵉⵏⵓⴺ',
    mm : '%d ⵎⵉⵏⵓⴺ',
    h : 'ⵙⴰⵄⴰ',
    hh : '%d ⵜⴰⵙⵙⴰⵄⵉⵏ',
    d : 'ⴰⵙⵙ',
    dd : '%d oⵙⵙⴰⵏ',
    M : 'ⴰⵢoⵓⵔ',
    MM : '%d ⵉⵢⵢⵉⵔⵏ',
    y : 'ⴰⵙⴳⴰⵙ',
    yy : '%d ⵉⵙⴳⴰⵙⵏ'
},
week : {
    dow : 6, // Saturday is the first day of the week.
    doy : 12  // The week that contains Jan 1st is the first week of the year.
}

});

return tzm;

})));

/***/ }), /* 143 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Central Atlas Tamazight Latin [tzm-latn] //! author : Abdel Said : github.com/abdelsaid

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var tzmLatn = moment.defineLocale('tzm-latn', {

months : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
monthsShort : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
weekdays : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
weekdaysShort : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
weekdaysMin : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd D MMMM YYYY HH:mm'
},
calendar : {
    sameDay: '[asdkh g] LT',
    nextDay: '[aska g] LT',
    nextWeek: 'dddd [g] LT',
    lastDay: '[assant g] LT',
    lastWeek: 'dddd [g] LT',
    sameElse: 'L'
},
relativeTime : {
    future : 'dadkh s yan %s',
    past : 'yan %s',
    s : 'imik',
    m : 'minuḍ',
    mm : '%d minuḍ',
    h : 'saɛa',
    hh : '%d tassaɛin',
    d : 'ass',
    dd : '%d ossan',
    M : 'ayowr',
    MM : '%d iyyirn',
    y : 'asgas',
    yy : '%d isgasn'
},
week : {
    dow : 6, // Saturday is the first day of the week.
    doy : 12  // The week that contains Jan 1st is the first week of the year.
}

});

return tzmLatn;

})));

/***/ }), /* 144 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Ukrainian [uk] //! author : zemlanin : github.com/zemlanin //! Author : Menelion Elensúle : github.com/Oire

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

function plural(word, num) {

var forms = word.split('_');
return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);

} function relativeTimeWithPlural(number, withoutSuffix, key) {

var format = {
    'mm': withoutSuffix ? 'хвилина_хвилини_хвилин' : 'хвилину_хвилини_хвилин',
    'hh': withoutSuffix ? 'година_години_годин' : 'годину_години_годин',
    'dd': 'день_дні_днів',
    'MM': 'місяць_місяці_місяців',
    'yy': 'рік_роки_років'
};
if (key === 'm') {
    return withoutSuffix ? 'хвилина' : 'хвилину';
}
else if (key === 'h') {
    return withoutSuffix ? 'година' : 'годину';
}
else {
    return number + ' ' + plural(format[key], +number);
}

} function weekdaysCaseReplace(m, format) {

var weekdays = {
    'nominative': 'неділя_понеділок_вівторок_середа_четвер_п’ятниця_субота'.split('_'),
    'accusative': 'неділю_понеділок_вівторок_середу_четвер_п’ятницю_суботу'.split('_'),
    'genitive': 'неділі_понеділка_вівторка_середи_четверга_п’ятниці_суботи'.split('_')
};

if (!m) {
    return weekdays['nominative'];
}

var nounCase = (/(\[[ВвУу]\]) ?dddd/).test(format) ?
    'accusative' :
    ((/\[?(?:минулої|наступної)? ?\] ?dddd/).test(format) ?
        'genitive' :
        'nominative');
return weekdays[nounCase][m.day()];

} function processHoursFunction(str) {

return function () {
    return str + 'о' + (this.hours() === 11 ? 'б' : '') + '] LT';
};

}

var uk = moment.defineLocale('uk', {

months : {
    'format': 'січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня'.split('_'),
    'standalone': 'січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень'.split('_')
},
monthsShort : 'січ_лют_бер_квіт_трав_черв_лип_серп_вер_жовт_лист_груд'.split('_'),
weekdays : weekdaysCaseReplace,
weekdaysShort : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
weekdaysMin : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD.MM.YYYY',
    LL : 'D MMMM YYYY р.',
    LLL : 'D MMMM YYYY р., HH:mm',
    LLLL : 'dddd, D MMMM YYYY р., HH:mm'
},
calendar : {
    sameDay: processHoursFunction('[Сьогодні '),
    nextDay: processHoursFunction('[Завтра '),
    lastDay: processHoursFunction('[Вчора '),
    nextWeek: processHoursFunction('[У] dddd ['),
    lastWeek: function () {
        switch (this.day()) {
            case 0:
            case 3:
            case 5:
            case 6:
                return processHoursFunction('[Минулої] dddd [').call(this);
            case 1:
            case 2:
            case 4:
                return processHoursFunction('[Минулого] dddd [').call(this);
        }
    },
    sameElse: 'L'
},
relativeTime : {
    future : 'за %s',
    past : '%s тому',
    s : 'декілька секунд',
    m : relativeTimeWithPlural,
    mm : relativeTimeWithPlural,
    h : 'годину',
    hh : relativeTimeWithPlural,
    d : 'день',
    dd : relativeTimeWithPlural,
    M : 'місяць',
    MM : relativeTimeWithPlural,
    y : 'рік',
    yy : relativeTimeWithPlural
},
// M. E.: those two are virtually unused but a user might want to implement them for his/her website for some reason
meridiemParse: /ночі|ранку|дня|вечора/,
isPM: function (input) {
    return /^(дня|вечора)$/.test(input);
},
meridiem : function (hour, minute, isLower) {
    if (hour < 4) {
        return 'ночі';
    } else if (hour < 12) {
        return 'ранку';
    } else if (hour < 17) {
        return 'дня';
    } else {
        return 'вечора';
    }
},
dayOfMonthOrdinalParse: /\d{1,2}-(й|го)/,
ordinal: function (number, period) {
    switch (period) {
        case 'M':
        case 'd':
        case 'DDD':
        case 'w':
        case 'W':
            return number + '-й';
        case 'D':
            return number + '-го';
        default:
            return number;
    }
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return uk;

})));

/***/ }), /* 145 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Urdu [ur] //! author : Sawood Alam : github.com/ibnesayeed //! author : Zack : github.com/ZackVision

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var months = [

'جنوری',
'فروری',
'مارچ',
'اپریل',
'مئی',
'جون',
'جولائی',
'اگست',
'ستمبر',
'اکتوبر',
'نومبر',
'دسمبر'

]; var days = [

'اتوار',
'پیر',
'منگل',
'بدھ',
'جمعرات',
'جمعہ',
'ہفتہ'

];

var ur = moment.defineLocale('ur', {

months : months,
monthsShort : months,
weekdays : days,
weekdaysShort : days,
weekdaysMin : days,
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd، D MMMM YYYY HH:mm'
},
meridiemParse: /صبح|شام/,
isPM : function (input) {
    return 'شام' === input;
},
meridiem : function (hour, minute, isLower) {
    if (hour < 12) {
        return 'صبح';
    }
    return 'شام';
},
calendar : {
    sameDay : '[آج بوقت] LT',
    nextDay : '[کل بوقت] LT',
    nextWeek : 'dddd [بوقت] LT',
    lastDay : '[گذشتہ روز بوقت] LT',
    lastWeek : '[گذشتہ] dddd [بوقت] LT',
    sameElse : 'L'
},
relativeTime : {
    future : '%s بعد',
    past : '%s قبل',
    s : 'چند سیکنڈ',
    m : 'ایک منٹ',
    mm : '%d منٹ',
    h : 'ایک گھنٹہ',
    hh : '%d گھنٹے',
    d : 'ایک دن',
    dd : '%d دن',
    M : 'ایک ماہ',
    MM : '%d ماہ',
    y : 'ایک سال',
    yy : '%d سال'
},
preparse: function (string) {
    return string.replace(/،/g, ',');
},
postformat: function (string) {
    return string.replace(/,/g, '،');
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return ur;

})));

/***/ }), /* 146 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Uzbek [uz] //! author : Sardor Muminov : github.com/muminoff

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var uz = moment.defineLocale('uz', {

months : 'январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр'.split('_'),
monthsShort : 'янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек'.split('_'),
weekdays : 'Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба'.split('_'),
weekdaysShort : 'Якш_Душ_Сеш_Чор_Пай_Жум_Шан'.split('_'),
weekdaysMin : 'Як_Ду_Се_Чо_Па_Жу_Ша'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'D MMMM YYYY, dddd HH:mm'
},
calendar : {
    sameDay : '[Бугун соат] LT [да]',
    nextDay : '[Эртага] LT [да]',
    nextWeek : 'dddd [куни соат] LT [да]',
    lastDay : '[Кеча соат] LT [да]',
    lastWeek : '[Утган] dddd [куни соат] LT [да]',
    sameElse : 'L'
},
relativeTime : {
    future : 'Якин %s ичида',
    past : 'Бир неча %s олдин',
    s : 'фурсат',
    m : 'бир дакика',
    mm : '%d дакика',
    h : 'бир соат',
    hh : '%d соат',
    d : 'бир кун',
    dd : '%d кун',
    M : 'бир ой',
    MM : '%d ой',
    y : 'бир йил',
    yy : '%d йил'
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 4th is the first week of the year.
}

});

return uz;

})));

/***/ }), /* 147 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Uzbek Latin [uz-latn] //! author : Rasulbek Mirzayev : github.com/Rasulbeeek

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var uzLatn = moment.defineLocale('uz-latn', {

months : 'Yanvar_Fevral_Mart_Aprel_May_Iyun_Iyul_Avgust_Sentabr_Oktabr_Noyabr_Dekabr'.split('_'),
monthsShort : 'Yan_Fev_Mar_Apr_May_Iyun_Iyul_Avg_Sen_Okt_Noy_Dek'.split('_'),
weekdays : 'Yakshanba_Dushanba_Seshanba_Chorshanba_Payshanba_Juma_Shanba'.split('_'),
weekdaysShort : 'Yak_Dush_Sesh_Chor_Pay_Jum_Shan'.split('_'),
weekdaysMin : 'Ya_Du_Se_Cho_Pa_Ju_Sha'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'D MMMM YYYY, dddd HH:mm'
},
calendar : {
    sameDay : '[Bugun soat] LT [da]',
    nextDay : '[Ertaga] LT [da]',
    nextWeek : 'dddd [kuni soat] LT [da]',
    lastDay : '[Kecha soat] LT [da]',
    lastWeek : '[O\'tgan] dddd [kuni soat] LT [da]',
    sameElse : 'L'
},
relativeTime : {
    future : 'Yaqin %s ichida',
    past : 'Bir necha %s oldin',
    s : 'soniya',
    m : 'bir daqiqa',
    mm : '%d daqiqa',
    h : 'bir soat',
    hh : '%d soat',
    d : 'bir kun',
    dd : '%d kun',
    M : 'bir oy',
    MM : '%d oy',
    y : 'bir yil',
    yy : '%d yil'
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 7  // The week that contains Jan 1st is the first week of the year.
}

});

return uzLatn;

})));

/***/ }), /* 148 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Vietnamese [vi] //! author : Bang Nguyen : github.com/bangnk

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var vi = moment.defineLocale('vi', {

months : 'tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12'.split('_'),
monthsShort : 'Th01_Th02_Th03_Th04_Th05_Th06_Th07_Th08_Th09_Th10_Th11_Th12'.split('_'),
monthsParseExact : true,
weekdays : 'chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy'.split('_'),
weekdaysShort : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
weekdaysMin : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
weekdaysParseExact : true,
meridiemParse: /sa|ch/i,
isPM : function (input) {
    return /^ch$/i.test(input);
},
meridiem : function (hours, minutes, isLower) {
    if (hours < 12) {
        return isLower ? 'sa' : 'SA';
    } else {
        return isLower ? 'ch' : 'CH';
    }
},
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM [năm] YYYY',
    LLL : 'D MMMM [năm] YYYY HH:mm',
    LLLL : 'dddd, D MMMM [năm] YYYY HH:mm',
    l : 'DD/M/YYYY',
    ll : 'D MMM YYYY',
    lll : 'D MMM YYYY HH:mm',
    llll : 'ddd, D MMM YYYY HH:mm'
},
calendar : {
    sameDay: '[Hôm nay lúc] LT',
    nextDay: '[Ngày mai lúc] LT',
    nextWeek: 'dddd [tuần tới lúc] LT',
    lastDay: '[Hôm qua lúc] LT',
    lastWeek: 'dddd [tuần rồi lúc] LT',
    sameElse: 'L'
},
relativeTime : {
    future : '%s tới',
    past : '%s trước',
    s : 'vài giây',
    m : 'một phút',
    mm : '%d phút',
    h : 'một giờ',
    hh : '%d giờ',
    d : 'một ngày',
    dd : '%d ngày',
    M : 'một tháng',
    MM : '%d tháng',
    y : 'một năm',
    yy : '%d năm'
},
dayOfMonthOrdinalParse: /\d{1,2}/,
ordinal : function (number) {
    return number;
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return vi;

})));

/***/ }), /* 149 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Pseudo [x-pseudo] //! author : Andrew Hood : github.com/andrewhood125

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var xPseudo = moment.defineLocale('x-pseudo', {

months : 'J~áñúá~rý_F~ébrú~árý_~Márc~h_Áp~ríl_~Máý_~Júñé~_Júl~ý_Áú~gúst~_Sép~témb~ér_Ó~ctób~ér_Ñ~óvém~bér_~Décé~mbér'.split('_'),
monthsShort : 'J~áñ_~Féb_~Már_~Ápr_~Máý_~Júñ_~Júl_~Áúg_~Sép_~Óct_~Ñóv_~Déc'.split('_'),
monthsParseExact : true,
weekdays : 'S~úñdá~ý_Mó~ñdáý~_Túé~sdáý~_Wéd~ñésd~áý_T~húrs~dáý_~Fríd~áý_S~átúr~dáý'.split('_'),
weekdaysShort : 'S~úñ_~Móñ_~Túé_~Wéd_~Thú_~Frí_~Sát'.split('_'),
weekdaysMin : 'S~ú_Mó~_Tú_~Wé_T~h_Fr~_Sá'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
    LT : 'HH:mm',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY HH:mm',
    LLLL : 'dddd, D MMMM YYYY HH:mm'
},
calendar : {
    sameDay : '[T~ódá~ý át] LT',
    nextDay : '[T~ómó~rró~w át] LT',
    nextWeek : 'dddd [át] LT',
    lastDay : '[Ý~ést~érdá~ý át] LT',
    lastWeek : '[L~ást] dddd [át] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'í~ñ %s',
    past : '%s á~gó',
    s : 'á ~féw ~sécó~ñds',
    m : 'á ~míñ~úté',
    mm : '%d m~íñú~tés',
    h : 'á~ñ hó~úr',
    hh : '%d h~óúrs',
    d : 'á ~dáý',
    dd : '%d d~áýs',
    M : 'á ~móñ~th',
    MM : '%d m~óñt~hs',
    y : 'á ~ýéár',
    yy : '%d ý~éárs'
},
dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
ordinal : function (number) {
    var b = number % 10,
        output = (~~(number % 100 / 10) === 1) ? 'th' :
        (b === 1) ? 'st' :
        (b === 2) ? 'nd' :
        (b === 3) ? 'rd' : 'th';
    return number + output;
},
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return xPseudo;

})));

/***/ }), /* 150 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Yoruba Nigeria [yo] //! author : Atolagbe Abisoye : github.com/andela-batolagbe

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var yo = moment.defineLocale('yo', {

months : 'Sẹ́rẹ́_Èrèlè_Ẹrẹ̀nà_Ìgbé_Èbibi_Òkùdu_Agẹmo_Ògún_Owewe_Ọ̀wàrà_Bélú_Ọ̀pẹ̀̀'.split('_'),
monthsShort : 'Sẹ́r_Èrl_Ẹrn_Ìgb_Èbi_Òkù_Agẹ_Ògú_Owe_Ọ̀wà_Bél_Ọ̀pẹ̀̀'.split('_'),
weekdays : 'Àìkú_Ajé_Ìsẹ́gun_Ọjọ́rú_Ọjọ́bọ_Ẹtì_Àbámẹ́ta'.split('_'),
weekdaysShort : 'Àìk_Ajé_Ìsẹ́_Ọjr_Ọjb_Ẹtì_Àbá'.split('_'),
weekdaysMin : 'Àì_Aj_Ìs_Ọr_Ọb_Ẹt_Àb'.split('_'),
longDateFormat : {
    LT : 'h:mm A',
    LTS : 'h:mm:ss A',
    L : 'DD/MM/YYYY',
    LL : 'D MMMM YYYY',
    LLL : 'D MMMM YYYY h:mm A',
    LLLL : 'dddd, D MMMM YYYY h:mm A'
},
calendar : {
    sameDay : '[Ònì ni] LT',
    nextDay : '[Ọ̀la ni] LT',
    nextWeek : 'dddd [Ọsẹ̀ tón\'bọ] [ni] LT',
    lastDay : '[Àna ni] LT',
    lastWeek : 'dddd [Ọsẹ̀ tólọ́] [ni] LT',
    sameElse : 'L'
},
relativeTime : {
    future : 'ní %s',
    past : '%s kọjá',
    s : 'ìsẹjú aayá die',
    m : 'ìsẹjú kan',
    mm : 'ìsẹjú %d',
    h : 'wákati kan',
    hh : 'wákati %d',
    d : 'ọjọ́ kan',
    dd : 'ọjọ́ %d',
    M : 'osù kan',
    MM : 'osù %d',
    y : 'ọdún kan',
    yy : 'ọdún %d'
},
dayOfMonthOrdinalParse : /ọjọ́\s\d{1,2}/,
ordinal : 'ọjọ́ %d',
week : {
    dow : 1, // Monday is the first day of the week.
    doy : 4 // The week that contains Jan 4th is the first week of the year.
}

});

return yo;

})));

/***/ }), /* 151 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Chinese (China) [zh-cn] //! author : suupic : github.com/suupic //! author : Zeno Zeng : github.com/zenozeng

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var zhCn = moment.defineLocale('zh-cn', {

months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
weekdaysShort : '周日_周一_周二_周三_周四_周五_周六'.split('_'),
weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'YYYY年MMMD日',
    LL : 'YYYY年MMMD日',
    LLL : 'YYYY年MMMD日Ah点mm分',
    LLLL : 'YYYY年MMMD日ddddAh点mm分',
    l : 'YYYY年MMMD日',
    ll : 'YYYY年MMMD日',
    lll : 'YYYY年MMMD日 HH:mm',
    llll : 'YYYY年MMMD日dddd HH:mm'
},
meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
meridiemHour: function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === '凌晨' || meridiem === '早上' ||
            meridiem === '上午') {
        return hour;
    } else if (meridiem === '下午' || meridiem === '晚上') {
        return hour + 12;
    } else {
        // '中午'
        return hour >= 11 ? hour : hour + 12;
    }
},
meridiem : function (hour, minute, isLower) {
    var hm = hour * 100 + minute;
    if (hm < 600) {
        return '凌晨';
    } else if (hm < 900) {
        return '早上';
    } else if (hm < 1130) {
        return '上午';
    } else if (hm < 1230) {
        return '中午';
    } else if (hm < 1800) {
        return '下午';
    } else {
        return '晚上';
    }
},
calendar : {
    sameDay : '[今天]LT',
    nextDay : '[明天]LT',
    nextWeek : '[下]ddddLT',
    lastDay : '[昨天]LT',
    lastWeek : '[上]ddddLT',
    sameElse : 'L'
},
dayOfMonthOrdinalParse: /\d{1,2}(日|月|周)/,
ordinal : function (number, period) {
    switch (period) {
        case 'd':
        case 'D':
        case 'DDD':
            return number + '日';
        case 'M':
            return number + '月';
        case 'w':
        case 'W':
            return number + '周';
        default:
            return number;
    }
},
relativeTime : {
    future : '%s内',
    past : '%s前',
    s : '几秒',
    m : '1 分钟',
    mm : '%d 分钟',
    h : '1 小时',
    hh : '%d 小时',
    d : '1 天',
    dd : '%d 天',
    M : '1 个月',
    MM : '%d 个月',
    y : '1 年',
    yy : '%d 年'
},
week : {
    // GB/T 7408-1994《数据元和交换格式·信息交换·日期和时间表示法》与ISO 8601:1988等效
    dow : 1, // Monday is the first day of the week.
    doy : 4  // The week that contains Jan 4th is the first week of the year.
}

});

return zhCn;

})));

/***/ }), /* 152 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Chinese (Hong Kong) [zh-hk] //! author : Ben : github.com/ben-lin //! author : Chris Lam : github.com/hehachris //! author : Konstantin : github.com/skfd

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var zhHk = moment.defineLocale('zh-hk', {

months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
weekdaysShort : '週日_週一_週二_週三_週四_週五_週六'.split('_'),
weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'YYYY年MMMD日',
    LL : 'YYYY年MMMD日',
    LLL : 'YYYY年MMMD日 HH:mm',
    LLLL : 'YYYY年MMMD日dddd HH:mm',
    l : 'YYYY年MMMD日',
    ll : 'YYYY年MMMD日',
    lll : 'YYYY年MMMD日 HH:mm',
    llll : 'YYYY年MMMD日dddd HH:mm'
},
meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === '凌晨' || meridiem === '早上' || meridiem === '上午') {
        return hour;
    } else if (meridiem === '中午') {
        return hour >= 11 ? hour : hour + 12;
    } else if (meridiem === '下午' || meridiem === '晚上') {
        return hour + 12;
    }
},
meridiem : function (hour, minute, isLower) {
    var hm = hour * 100 + minute;
    if (hm < 600) {
        return '凌晨';
    } else if (hm < 900) {
        return '早上';
    } else if (hm < 1130) {
        return '上午';
    } else if (hm < 1230) {
        return '中午';
    } else if (hm < 1800) {
        return '下午';
    } else {
        return '晚上';
    }
},
calendar : {
    sameDay : '[今天]LT',
    nextDay : '[明天]LT',
    nextWeek : '[下]ddddLT',
    lastDay : '[昨天]LT',
    lastWeek : '[上]ddddLT',
    sameElse : 'L'
},
dayOfMonthOrdinalParse: /\d{1,2}(日|月|週)/,
ordinal : function (number, period) {
    switch (period) {
        case 'd' :
        case 'D' :
        case 'DDD' :
            return number + '日';
        case 'M' :
            return number + '月';
        case 'w' :
        case 'W' :
            return number + '週';
        default :
            return number;
    }
},
relativeTime : {
    future : '%s內',
    past : '%s前',
    s : '幾秒',
    m : '1 分鐘',
    mm : '%d 分鐘',
    h : '1 小時',
    hh : '%d 小時',
    d : '1 天',
    dd : '%d 天',
    M : '1 個月',
    MM : '%d 個月',
    y : '1 年',
    yy : '%d 年'
}

});

return zhHk;

})));

/***/ }), /* 153 */ /***/ (function(module, exports, webpack_require) {

//! moment.js locale configuration //! locale : Chinese (Taiwan) [zh-tw] //! author : Ben : github.com/ben-lin //! author : Chris Lam : github.com/hehachris

;(function (global, factory) {

 true ? factory(__webpack_require__(0)) :
typeof define === 'function' && define.amd ? define(['../moment'], factory) :
factory(global.moment)

}(this, (function (moment) { 'use strict';

var zhTw = moment.defineLocale('zh-tw', {

months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
weekdaysShort : '週日_週一_週二_週三_週四_週五_週六'.split('_'),
weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
longDateFormat : {
    LT : 'HH:mm',
    LTS : 'HH:mm:ss',
    L : 'YYYY年MMMD日',
    LL : 'YYYY年MMMD日',
    LLL : 'YYYY年MMMD日 HH:mm',
    LLLL : 'YYYY年MMMD日dddd HH:mm',
    l : 'YYYY年MMMD日',
    ll : 'YYYY年MMMD日',
    lll : 'YYYY年MMMD日 HH:mm',
    llll : 'YYYY年MMMD日dddd HH:mm'
},
meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
meridiemHour : function (hour, meridiem) {
    if (hour === 12) {
        hour = 0;
    }
    if (meridiem === '凌晨' || meridiem === '早上' || meridiem === '上午') {
        return hour;
    } else if (meridiem === '中午') {
        return hour >= 11 ? hour : hour + 12;
    } else if (meridiem === '下午' || meridiem === '晚上') {
        return hour + 12;
    }
},
meridiem : function (hour, minute, isLower) {
    var hm = hour * 100 + minute;
    if (hm < 600) {
        return '凌晨';
    } else if (hm < 900) {
        return '早上';
    } else if (hm < 1130) {
        return '上午';
    } else if (hm < 1230) {
        return '中午';
    } else if (hm < 1800) {
        return '下午';
    } else {
        return '晚上';
    }
},
calendar : {
    sameDay : '[今天]LT',
    nextDay : '[明天]LT',
    nextWeek : '[下]ddddLT',
    lastDay : '[昨天]LT',
    lastWeek : '[上]ddddLT',
    sameElse : 'L'
},
dayOfMonthOrdinalParse: /\d{1,2}(日|月|週)/,
ordinal : function (number, period) {
    switch (period) {
        case 'd' :
        case 'D' :
        case 'DDD' :
            return number + '日';
        case 'M' :
            return number + '月';
        case 'w' :
        case 'W' :
            return number + '週';
        default :
            return number;
    }
},
relativeTime : {
    future : '%s內',
    past : '%s前',
    s : '幾秒',
    m : '1 分鐘',
    mm : '%d 分鐘',
    h : '1 小時',
    hh : '%d 小時',
    d : '1 天',
    dd : '%d 天',
    M : '1 個月',
    MM : '%d 個月',
    y : '1 年',
    yy : '%d 年'
}

});

return zhTw;

})));

/***/ }), /* 154 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.getSubGraphs = exports.indexNodes = exports.getDepthFirstPos = exports.addSubGraph = exports.defaultStyle = exports.clear = exports.getClasses = exports.getEdges = exports.getVertices = exports.getDirection = exports.bindFunctions = exports.setClickEvent = exports.getTooltip = exports.setClass = exports.setDirection = exports.addClass = exports.updateLink = exports.updateLinkInterpolate = exports.addLink = exports.addVertex = undefined;

var _typeof = typeof Symbol === “function” && typeof Symbol.iterator === “symbol” ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === “function” && obj.constructor === Symbol && obj !== Symbol.prototype ? “symbol” : typeof obj; };

var _logger = webpack_require(1);

var _utils = webpack_require(155);

var _utils2 = _interopRequireDefault(_utils);

var _d = webpack_require(6);

var _d2 = _interopRequireDefault(_d);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var vertices = {}; var edges = []; var classes = []; var subGraphs = []; var tooltips = {}; var subCount = 0; var direction; // Functions to be run after graph rendering var funs = []; /**

* Function called by parser when a node definition has been found
* @param id
* @param text
* @param type
* @param style
*/

var addVertex = exports.addVertex = function addVertex(id, text, type, style) {

var txt;

if (typeof id === 'undefined') {
  return;
}
if (id.trim().length === 0) {
  return;
}

if (typeof vertices[id] === 'undefined') {
  vertices[id] = { id: id, styles: [], classes: [] };
}
if (typeof text !== 'undefined') {
  txt = text.trim();

  // strip quotes if string starts and exnds with a quote
  if (txt[0] === '"' && txt[txt.length - 1] === '"') {
    txt = txt.substring(1, txt.length - 1);
  }

  vertices[id].text = txt;
}
if (typeof type !== 'undefined') {
  vertices[id].type = type;
}
if (typeof type !== 'undefined') {
  vertices[id].type = type;
}
if (typeof style !== 'undefined') {
  if (style !== null) {
    style.forEach(function (s) {
      vertices[id].styles.push(s);
    });
  }
}

};

/**

* Function called by parser when a link/edge definition has been found
* @param start
* @param end
* @param type
* @param linktext
*/

var addLink = exports.addLink = function addLink(start, end, type, linktext) {

_logger.logger.info('Got edge...', start, end);
var edge = { start: start, end: end, type: undefined, text: '' };
linktext = type.text;

if (typeof linktext !== 'undefined') {
  edge.text = linktext.trim();

  // strip quotes if string starts and exnds with a quote
  if (edge.text[0] === '"' && edge.text[edge.text.length - 1] === '"') {
    edge.text = edge.text.substring(1, edge.text.length - 1);
  }
}

if (typeof type !== 'undefined') {
  edge.type = type.type;
  edge.stroke = type.stroke;
}
edges.push(edge);

};

/**

* Updates a link's line interpolation algorithm
* @param pos
* @param interpolate
*/

var updateLinkInterpolate = exports.updateLinkInterpolate = function updateLinkInterpolate(pos, interp) {

if (pos === 'default') {
  edges.defaultInterpolate = interp;
} else {
  edges[pos].interpolate = interp;
}

};

/**

* Updates a link with a style
* @param pos
* @param style
*/

var updateLink = exports.updateLink = function updateLink(pos, style) {

if (pos === 'default') {
  edges.defaultStyle = style;
} else {
  if (_utils2.default.isSubstringInArray('fill', style) === -1) {
    style.push('fill:none');
  }
  edges[pos].style = style;
}

};

var addClass = exports.addClass = function addClass(id, style) {

if (typeof classes[id] === 'undefined') {
  classes[id] = { id: id, styles: [] };
}

if (typeof style !== 'undefined') {
  if (style !== null) {
    style.forEach(function (s) {
      classes[id].styles.push(s);
    });
  }
}

};

/**

* Called by parser when a graph definition is found, stores the direction of the chart.
* @param dir
*/

var setDirection = exports.setDirection = function setDirection(dir) {

direction = dir;

};

/**

* Called by parser when a graph definition is found, stores the direction of the chart.
* @param dir
*/

var setClass = exports.setClass = function setClass(id, className) {

if (id.indexOf(',') > 0) {
  id.split(',').forEach(function (id2) {
    if (typeof vertices[id2] !== 'undefined') {
      vertices[id2].classes.push(className);
    }
  });
} else {
  if (typeof vertices[id] !== 'undefined') {
    vertices[id].classes.push(className);
  }
}

};

var setTooltip = function setTooltip(id, tooltip) {

if (typeof tooltip !== 'undefined') {
  tooltips[id] = tooltip;
}

};

var setClickFun = function setClickFun(id, functionName) {

if (typeof functionName === 'undefined') {
  return;
}
if (typeof vertices[id] !== 'undefined') {
  funs.push(function (element) {
    var elem = _d2.default.select(element).select('#' + id);
    if (elem !== null) {
      elem.on('click', function () {
        window[functionName](id);
      });
    }
  });
}

};

var setLink = function setLink(id, linkStr) {

if (typeof linkStr === 'undefined') {
  return;
}
if (typeof vertices[id] !== 'undefined') {
  funs.push(function (element) {
    var elem = _d2.default.select(element).select('#' + id);
    if (elem !== null) {
      elem.on('click', function () {
        window.open(linkStr, 'newTab');
      });
    }
  });
}

}; var getTooltip = exports.getTooltip = function getTooltip(id) {

return tooltips[id];

};

/**

* Called by parser when a graph definition is found, stores the direction of the chart.
* @param dir
*/

var setClickEvent = exports.setClickEvent = function setClickEvent(id, functionName, link, tooltip) {

if (id.indexOf(',') > 0) {
  id.split(',').forEach(function (id2) {
    setTooltip(id2, tooltip);
    setClickFun(id2, functionName);
    setLink(id2, link);
  });
} else {
  setTooltip(id, tooltip);
  setClickFun(id, functionName);
  setLink(id, link);
}

};

var bindFunctions = exports.bindFunctions = function bindFunctions(element) {

funs.forEach(function (fun) {
  fun(element);
});

}; var getDirection = exports.getDirection = function getDirection() {

return direction;

}; /**

* Retrieval function for fetching the found nodes after parsing has completed.
* @returns {{}|*|vertices}
*/

var getVertices = exports.getVertices = function getVertices() {

return vertices;

};

/**

* Retrieval function for fetching the found links after parsing has completed.
* @returns {{}|*|edges}
*/

var getEdges = exports.getEdges = function getEdges() {

return edges;

};

/**

* Retrieval function for fetching the found class definitions after parsing has completed.
* @returns {{}|*|classes}
*/

var getClasses = exports.getClasses = function getClasses() {

return classes;

};

var setupToolTips = function setupToolTips(element) {

var tooltipElem = _d2.default.select('.mermaidTooltip');
if (tooltipElem[0][0] === null) {
  tooltipElem = _d2.default.select('body').append('div').attr('class', 'mermaidTooltip').style('opacity', 0);
}

var svg = _d2.default.select(element).select('svg');

var nodes = svg.selectAll('g.node');
nodes.on('mouseover', function () {
  var el = _d2.default.select(this);
  var title = el.attr('title');
  // Dont try to draw a tooltip if no data is provided
  if (title === null) {
    return;
  }
  var rect = this.getBoundingClientRect();

  tooltipElem.transition().duration(200).style('opacity', '.9');
  tooltipElem.html(el.attr('title')).style('left', rect.left + (rect.right - rect.left) / 2 + 'px').style('top', rect.top - 14 + document.body.scrollTop + 'px');
  el.classed('hover', true);
}).on('mouseout', function () {
  tooltipElem.transition().duration(500).style('opacity', 0);
  var el = _d2.default.select(this);
  el.classed('hover', false);
});

}; funs.push(setupToolTips);

/**

* Clears the internal graph db so that a new graph can be parsed.
*/

var clear = exports.clear = function clear() {

vertices = {};
classes = {};
edges = [];
funs = [];
funs.push(setupToolTips);
subGraphs = [];
subCount = 0;
tooltips = [];

}; /**

*
* @returns {string}
*/

var defaultStyle = exports.defaultStyle = function defaultStyle() {

return 'fill:#ffa;stroke: #f66; stroke-width: 3px; stroke-dasharray: 5, 5;fill:#ffa;stroke: #666;';

};

/**

* Clears the internal graph db so that a new graph can be parsed.
*/

var addSubGraph = exports.addSubGraph = function addSubGraph(list, title) {

function uniq(a) {
  var prims = { 'boolean': {}, 'number': {}, 'string': {} };
  var objs = [];

  return a.filter(function (item) {
    var type = typeof item === 'undefined' ? 'undefined' : _typeof(item);
    if (item === ' ') {
      return false;
    }
    if (type in prims) {
      return prims[type].hasOwnProperty(item) ? false : prims[type][item] = true;
    } else {
      return objs.indexOf(item) >= 0 ? false : objs.push(item);
    }
  });
}

var nodeList = [];

nodeList = uniq(nodeList.concat.apply(nodeList, list));

var subGraph = { id: 'subGraph' + subCount, nodes: nodeList, title: title };
subGraphs.push(subGraph);
subCount = subCount + 1;
return subGraph.id;

};

var getPosForId = function getPosForId(id) {

var i;
for (i = 0; i < subGraphs.length; i++) {
  if (subGraphs[i].id === id) {
    return i;
  }
}
return -1;

}; var secCount = -1; var posCrossRef = []; var indexNodes2 = function indexNodes2(id, pos) {

var nodes = subGraphs[pos].nodes;
secCount = secCount + 1;
if (secCount > 2000) {
  return;
}
posCrossRef[secCount] = pos;
// Check if match
if (subGraphs[pos].id === id) {
  return {
    result: true,
    count: 0
  };
}

var count = 0;
var posCount = 1;
while (count < nodes.length) {
  var childPos = getPosForId(nodes[count]);
  // Ignore regular nodes (pos will be -1)
  if (childPos >= 0) {
    var res = indexNodes2(id, childPos);
    if (res.result) {
      return {
        result: true,
        count: posCount + res.count
      };
    } else {
      posCount = posCount + res.count;
    }
  }
  count = count + 1;
}

return {
  result: false,
  count: posCount
};

};

var getDepthFirstPos = exports.getDepthFirstPos = function getDepthFirstPos(pos) {

return posCrossRef[pos];

}; var indexNodes = exports.indexNodes = function indexNodes() {

secCount = -1;
if (subGraphs.length > 0) {
  indexNodes2('none', subGraphs.length - 1, 0);
}

};

var getSubGraphs = exports.getSubGraphs = function getSubGraphs() {

return subGraphs;

};

exports.default = {

addVertex: addVertex,
addLink: addLink,
updateLinkInterpolate: updateLinkInterpolate,
updateLink: updateLink,
addClass: addClass,
setDirection: setDirection,
setClass: setClass,
getTooltip: getTooltip,
setClickEvent: setClickEvent,
bindFunctions: bindFunctions,
getDirection: getDirection,
getVertices: getVertices,
getEdges: getEdges,
getClasses: getClasses,
clear: clear,
defaultStyle: defaultStyle,
addSubGraph: addSubGraph,
getDepthFirstPos: getDepthFirstPos,
indexNodes: indexNodes,
getSubGraphs: getSubGraphs

};

/***/ }), /* 155 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.isSubstringInArray = exports.cloneCssStyles = exports.detectType = undefined;

var _logger = webpack_require(1);

/**

* @function detectType
* Detects the type of the graph text.
* ```mermaid
* graph LR
*  a-->b
*  b-->c
*  c-->d
*  d-->e
*  e-->f
*  f-->g
*  g-->h
* ```
*
* @param {string} text The text defining the graph
* @returns {string} A graph definition key
*/

var detectType = exports.detectType = function detectType(text) {

text = text.replace(/^\s*%%.*\n/g, '\n');
if (text.match(/^\s*sequenceDiagram/)) {
  return 'sequenceDiagram';
}

if (text.match(/^\s*digraph/)) {
  return 'dotGraph';
}

if (text.match(/^\s*info/)) {
  return 'info';
}

if (text.match(/^\s*gantt/)) {
  return 'gantt';
}

if (text.match(/^\s*classDiagram/)) {
  _logger.logger.debug('Detected classDiagram syntax');
  return 'classDiagram';
}

if (text.match(/^\s*gitGraph/)) {
  _logger.logger.debug('Detected gitGraph syntax');
  return 'gitGraph';
}
return 'graph';

};

/**

* Copies all relevant CSS content into the graph SVG.
* This allows the SVG to be copied as is while keeping class based styling
* @param {element} svg The root element of the SVG
* @param {object} Hash table of class definitions from the graph definition
*/

var cloneCssStyles = exports.cloneCssStyles = function cloneCssStyles(svg, classes) {

var usedStyles = '';
var sheets = document.styleSheets;
var rule = void 0;
for (var i = 0; i < sheets.length; i++) {
  // Avoid multiple inclusion on pages with multiple graphs
  if (sheets[i].title !== 'mermaid-svg-internal-css') {
    try {
      var rules = sheets[i].cssRules;
      if (rules !== null) {
        for (var j = 0; j < rules.length; j++) {
          rule = rules[j];
          if (typeof rule.style !== 'undefined') {
            var elems = svg.querySelectorAll(rule.selectorText);
            if (elems.length > 0) {
              usedStyles += rule.selectorText + ' { ' + rule.style.cssText + '}\n';
            }
          }
        }
      }
    } catch (err) {
      if (typeof rule !== 'undefined') {
        _logger.logger.warn('Invalid CSS selector "' + rule.selectorText + '"', err);
      }
    }
  }
}

var defaultStyles = '';
var embeddedStyles = '';
for (var className in classes) {
  if (classes.hasOwnProperty(className) && typeof className !== 'undefined') {
    if (className === 'default') {
      if (classes.default.styles instanceof Array) {
        defaultStyles += '#' + svg.id.trim() + ' .node' + '>rect { ' + classes[className].styles.join('; ') + '; }\n';
      }
      if (classes.default.nodeLabelStyles instanceof Array) {
        defaultStyles += '#' + svg.id.trim() + ' .node text ' + ' { ' + classes[className].nodeLabelStyles.join('; ') + '; }\n';
      }
      if (classes.default.edgeLabelStyles instanceof Array) {
        defaultStyles += '#' + svg.id.trim() + ' .edgeLabel text ' + ' { ' + classes[className].edgeLabelStyles.join('; ') + '; }\n';
      }
      if (classes.default.clusterStyles instanceof Array) {
        defaultStyles += '#' + svg.id.trim() + ' .cluster rect ' + ' { ' + classes[className].clusterStyles.join('; ') + '; }\n';
      }
    } else {
      if (classes[className].styles instanceof Array) {
        embeddedStyles += '#' + svg.id.trim() + ' .' + className + '>rect, .' + className + '>polygon, .' + className + '>circle, .' + className + '>ellipse { ' + classes[className].styles.join('; ') + '; }\n';
      }
    }
  }
}

if (usedStyles !== '' || defaultStyles !== '' || embeddedStyles !== '') {
  var s = document.createElement('style');
  s.setAttribute('type', 'text/css');
  s.setAttribute('title', 'mermaid-svg-internal-css');
  s.innerHTML = '/* <![CDATA[ */\n';
  // Make this CSS local to this SVG
  if (defaultStyles !== '') {
    s.innerHTML += defaultStyles;
  }
  if (usedStyles !== '') {
    s.innerHTML += usedStyles;
  }
  if (embeddedStyles !== '') {
    s.innerHTML += embeddedStyles;
  }
  s.innerHTML += '/* ]]> */\n';
  svg.insertBefore(s, svg.firstChild);
}

};

/**

* @function isSubstringInArray
* Detects whether a substring in present in a given array
* @param {string} str The substring to detect
* @param {array} arr The array to search
* @returns {number} the array index containing the substring or -1 if not present
**/

var isSubstringInArray = exports.isSubstringInArray = function isSubstringInArray(str, arr) {

for (var i = 0; i < arr.length; i++) {
  if (arr[i].match(str)) return i;
}
return -1;

};

exports.default = {

detectType: detectType,
cloneCssStyles: cloneCssStyles,
isSubstringInArray: isSubstringInArray

};

/***/ }), /* 156 */ /***/ (function(module, exports, webpack_require) {

“use strict”; /* WEBPACK VAR INJECTION */(function(process, module) {

/* parser generated by jison 0.4.17 */ /*

Returns a Parser object of the following structure:

Parser: {
  yy: {}
}

Parser.prototype: {
  yy: {},
  trace: function(),
  symbols_: {associative list: name ==> number},
  terminals_: {associative list: number ==> name},
  productions_: [...],
  performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
  table: [...],
  defaultActions: {...},
  parseError: function(str, hash),
  parse: function(input),

  lexer: {
      EOF: 1,
      parseError: function(str, hash),
      setInput: function(input),
      input: function(),
      unput: function(str),
      more: function(),
      less: function(n),
      pastInput: function(),
      upcomingInput: function(),
      showPosition: function(),
      test_match: function(regex_match_array, rule_index),
      next: function(),
      lex: function(),
      begin: function(condition),
      popState: function(),
      _currentRules: function(),
      topState: function(),
      pushState: function(condition),

      options: {
          ranges: boolean           (optional: true ==> token location info will include a .range[] member)
          flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
          backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
      },

      performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
      rules: [...],
      conditions: {associative list: name ==> set},
  }
}

token location info (@$, _$, etc.): {
  first_line: n,
  last_line: n,
  first_column: n,
  last_column: n,
  range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
}

the parseError function receives a 'hash' object with these members for lexer and parser errors: {
  text:        (matched text)
  token:       (the produced terminal token, if any)
  line:        (yylineno)
}
while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
  loc:         (yylloc)
  expected:    (string describing the set of expected tokens)
  recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
}

*/ var parser = function () {

var o = function o(k, v, _o, l) {
    for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v) {}return _o;
},
    $V0 = [1, 4],
    $V1 = [1, 3],
    $V2 = [1, 5],
    $V3 = [1, 8, 9, 10, 11, 13, 18, 30, 46, 71, 72, 73, 74, 75, 81, 86, 88, 89, 91, 92, 94, 95, 96, 97, 98],
    $V4 = [2, 2],
    $V5 = [1, 12],
    $V6 = [1, 13],
    $V7 = [1, 14],
    $V8 = [1, 15],
    $V9 = [1, 31],
    $Va = [1, 33],
    $Vb = [1, 22],
    $Vc = [1, 34],
    $Vd = [1, 24],
    $Ve = [1, 25],
    $Vf = [1, 26],
    $Vg = [1, 27],
    $Vh = [1, 28],
    $Vi = [1, 38],
    $Vj = [1, 40],
    $Vk = [1, 35],
    $Vl = [1, 39],
    $Vm = [1, 45],
    $Vn = [1, 44],
    $Vo = [1, 36],
    $Vp = [1, 37],
    $Vq = [1, 41],
    $Vr = [1, 42],
    $Vs = [1, 43],
    $Vt = [1, 8, 9, 10, 11, 13, 18, 30, 32, 46, 71, 72, 73, 74, 75, 81, 86, 88, 89, 91, 92, 94, 95, 96, 97, 98],
    $Vu = [1, 53],
    $Vv = [1, 52],
    $Vw = [1, 54],
    $Vx = [1, 72],
    $Vy = [1, 80],
    $Vz = [1, 81],
    $VA = [1, 66],
    $VB = [1, 65],
    $VC = [1, 85],
    $VD = [1, 84],
    $VE = [1, 82],
    $VF = [1, 83],
    $VG = [1, 73],
    $VH = [1, 68],
    $VI = [1, 67],
    $VJ = [1, 63],
    $VK = [1, 75],
    $VL = [1, 76],
    $VM = [1, 77],
    $VN = [1, 78],
    $VO = [1, 79],
    $VP = [1, 70],
    $VQ = [1, 69],
    $VR = [8, 9, 11],
    $VS = [8, 9, 11, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64],
    $VT = [1, 115],
    $VU = [8, 9, 10, 11, 13, 15, 18, 36, 38, 40, 42, 46, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 81, 86, 88, 89, 91, 92, 94, 95, 96, 97, 98],
    $VV = [8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 30, 32, 36, 37, 38, 39, 40, 41, 42, 43, 46, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 71, 72, 73, 74, 75, 78, 81, 84, 86, 88, 89, 91, 92, 94, 95, 96, 97, 98],
    $VW = [1, 117],
    $VX = [1, 118],
    $VY = [8, 9, 10, 11, 13, 18, 30, 32, 46, 71, 72, 73, 74, 75, 81, 86, 88, 89, 91, 92, 94, 95, 96, 97, 98],
    $VZ = [8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 30, 32, 37, 39, 41, 43, 46, 50, 51, 52, 53, 54, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 71, 72, 73, 74, 75, 78, 81, 84, 86, 88, 89, 91, 92, 94, 95, 96, 97, 98],
    $V_ = [13, 18, 46, 81, 86, 88, 89, 91, 92, 94, 95, 96, 97, 98],
    $V$ = [13, 18, 46, 49, 65, 81, 86, 88, 89, 91, 92, 94, 95, 96, 97, 98],
    $V01 = [1, 191],
    $V11 = [1, 188],
    $V21 = [1, 195],
    $V31 = [1, 192],
    $V41 = [1, 189],
    $V51 = [1, 196],
    $V61 = [1, 186],
    $V71 = [1, 187],
    $V81 = [1, 190],
    $V91 = [1, 193],
    $Va1 = [1, 194],
    $Vb1 = [1, 213],
    $Vc1 = [8, 9, 11, 86],
    $Vd1 = [8, 9, 10, 11, 46, 71, 80, 81, 84, 86, 88, 89, 90, 91, 92];
var parser = { trace: function trace() {},
    yy: {},
    symbols_: { "error": 2, "mermaidDoc": 3, "graphConfig": 4, "document": 5, "line": 6, "statement": 7, "SEMI": 8, "NEWLINE": 9, "SPACE": 10, "EOF": 11, "GRAPH": 12, "DIR": 13, "FirstStmtSeperator": 14, "TAGEND": 15, "TAGSTART": 16, "UP": 17, "DOWN": 18, "ending": 19, "endToken": 20, "spaceList": 21, "spaceListNewline": 22, "verticeStatement": 23, "separator": 24, "styleStatement": 25, "linkStyleStatement": 26, "classDefStatement": 27, "classStatement": 28, "clickStatement": 29, "subgraph": 30, "text": 31, "end": 32, "vertex": 33, "link": 34, "alphaNum": 35, "SQS": 36, "SQE": 37, "PS": 38, "PE": 39, "(-": 40, "-)": 41, "DIAMOND_START": 42, "DIAMOND_STOP": 43, "alphaNumStatement": 44, "alphaNumToken": 45, "MINUS": 46, "linkStatement": 47, "arrowText": 48, "TESTSTR": 49, "--": 50, "ARROW_POINT": 51, "ARROW_CIRCLE": 52, "ARROW_CROSS": 53, "ARROW_OPEN": 54, "-.": 55, "DOTTED_ARROW_POINT": 56, "DOTTED_ARROW_CIRCLE": 57, "DOTTED_ARROW_CROSS": 58, "DOTTED_ARROW_OPEN": 59, "==": 60, "THICK_ARROW_POINT": 61, "THICK_ARROW_CIRCLE": 62, "THICK_ARROW_CROSS": 63, "THICK_ARROW_OPEN": 64, "PIPE": 65, "textToken": 66, "STR": 67, "commentText": 68, "commentToken": 69, "keywords": 70, "STYLE": 71, "LINKSTYLE": 72, "CLASSDEF": 73, "CLASS": 74, "CLICK": 75, "textNoTags": 76, "textNoTagsToken": 77, "DEFAULT": 78, "stylesOpt": 79, "HEX": 80, "NUM": 81, "INTERPOLATE": 82, "commentStatement": 83, "PCT": 84, "style": 85, "COMMA": 86, "styleComponent": 87, "ALPHA": 88, "COLON": 89, "UNIT": 90, "BRKT": 91, "DOT": 92, "graphCodeTokens": 93, "PUNCTUATION": 94, "UNICODE_TEXT": 95, "PLUS": 96, "EQUALS": 97, "MULT": 98, "TAG_START": 99, "TAG_END": 100, "QUOTE": 101, "$accept": 0, "$end": 1 },
    terminals_: { 2: "error", 8: "SEMI", 9: "NEWLINE", 10: "SPACE", 11: "EOF", 12: "GRAPH", 13: "DIR", 15: "TAGEND", 16: "TAGSTART", 17: "UP", 18: "DOWN", 30: "subgraph", 32: "end", 36: "SQS", 37: "SQE", 38: "PS", 39: "PE", 40: "(-", 41: "-)", 42: "DIAMOND_START", 43: "DIAMOND_STOP", 46: "MINUS", 49: "TESTSTR", 50: "--", 51: "ARROW_POINT", 52: "ARROW_CIRCLE", 53: "ARROW_CROSS", 54: "ARROW_OPEN", 55: "-.", 56: "DOTTED_ARROW_POINT", 57: "DOTTED_ARROW_CIRCLE", 58: "DOTTED_ARROW_CROSS", 59: "DOTTED_ARROW_OPEN", 60: "==", 61: "THICK_ARROW_POINT", 62: "THICK_ARROW_CIRCLE", 63: "THICK_ARROW_CROSS", 64: "THICK_ARROW_OPEN", 65: "PIPE", 67: "STR", 71: "STYLE", 72: "LINKSTYLE", 73: "CLASSDEF", 74: "CLASS", 75: "CLICK", 78: "DEFAULT", 80: "HEX", 81: "NUM", 82: "INTERPOLATE", 84: "PCT", 86: "COMMA", 88: "ALPHA", 89: "COLON", 90: "UNIT", 91: "BRKT", 92: "DOT", 94: "PUNCTUATION", 95: "UNICODE_TEXT", 96: "PLUS", 97: "EQUALS", 98: "MULT", 99: "TAG_START", 100: "TAG_END", 101: "QUOTE" },
    productions_: [0, [3, 2], [5, 0], [5, 2], [6, 1], [6, 1], [6, 1], [6, 1], [6, 1], [4, 2], [4, 2], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [19, 2], [19, 1], [20, 1], [20, 1], [20, 1], [14, 1], [14, 1], [14, 2], [22, 2], [22, 2], [22, 1], [22, 1], [21, 2], [21, 1], [7, 2], [7, 2], [7, 2], [7, 2], [7, 2], [7, 2], [7, 5], [7, 4], [24, 1], [24, 1], [24, 1], [23, 3], [23, 1], [33, 4], [33, 5], [33, 6], [33, 7], [33, 4], [33, 5], [33, 4], [33, 5], [33, 4], [33, 5], [33, 4], [33, 5], [33, 1], [33, 2], [35, 1], [35, 2], [44, 1], [44, 1], [44, 1], [44, 1], [34, 2], [34, 3], [34, 3], [34, 1], [34, 3], [34, 3], [34, 3], [34, 3], [34, 3], [34, 3], [34, 3], [34, 3], [34, 3], [34, 3], [34, 3], [34, 3], [47, 1], [47, 1], [47, 1], [47, 1], [47, 1], [47, 1], [47, 1], [47, 1], [47, 1], [47, 1], [47, 1], [47, 1], [48, 3], [31, 1], [31, 2], [31, 1], [68, 1], [68, 2], [70, 1], [70, 1], [70, 1], [70, 1], [70, 1], [70, 1], [70, 1], [70, 1], [70, 1], [70, 1], [70, 1], [76, 1], [76, 2], [27, 5], [27, 5], [28, 5], [29, 5], [29, 7], [29, 5], [29, 7], [25, 5], [25, 5], [26, 5], [26, 5], [26, 9], [26, 9], [26, 7], [26, 7], [83, 3], [79, 1], [79, 3], [85, 1], [85, 2], [87, 1], [87, 1], [87, 1], [87, 1], [87, 1], [87, 1], [87, 1], [87, 1], [87, 1], [87, 1], [87, 1], [69, 1], [69, 1], [66, 1], [66, 1], [66, 1], [66, 1], [66, 1], [66, 1], [66, 1], [77, 1], [77, 1], [77, 1], [77, 1], [45, 1], [45, 1], [45, 1], [45, 1], [45, 1], [45, 1], [45, 1], [45, 1], [45, 1], [45, 1], [45, 1], [93, 1], [93, 1], [93, 1], [93, 1], [93, 1], [93, 1], [93, 1], [93, 1], [93, 1], [93, 1], [93, 1], [93, 1], [93, 1], [93, 1], [93, 1]],
    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
        /* this == yyval */

        var $0 = $$.length - 1;
        switch (yystate) {
            case 2:
                this.$ = [];
                break;
            case 3:

                if ($$[$0] !== []) {
                    $$[$0 - 1].push($$[$0]);
                }
                this.$ = $$[$0 - 1];
                break;
            case 4:case 57:case 59:case 60:case 92:case 94:case 95:case 108:
                this.$ = $$[$0];
                break;
            case 11:
                yy.setDirection($$[$0 - 1]);this.$ = $$[$0 - 1];
                break;
            case 12:
                yy.setDirection("LR");this.$ = $$[$0 - 1];
                break;
            case 13:
                yy.setDirection("RL");this.$ = $$[$0 - 1];
                break;
            case 14:
                yy.setDirection("BT");this.$ = $$[$0 - 1];
                break;
            case 15:
                yy.setDirection("TB");this.$ = $$[$0 - 1];
                break;
            case 30:
                this.$ = $$[$0 - 1];
                break;
            case 31:case 32:case 33:case 34:case 35:
                this.$ = [];
                break;
            case 36:
                this.$ = yy.addSubGraph($$[$0 - 1], $$[$0 - 3]);
                break;
            case 37:
                this.$ = yy.addSubGraph($$[$0 - 1], undefined);
                break;
            case 41:
                yy.addLink($$[$0 - 2], $$[$0], $$[$0 - 1]);this.$ = [$$[$0 - 2], $$[$0]];
                break;
            case 42:
                this.$ = [$$[$0]];
                break;
            case 43:
                this.$ = $$[$0 - 3];yy.addVertex($$[$0 - 3], $$[$0 - 1], 'square');
                break;
            case 44:
                this.$ = $$[$0 - 4];yy.addVertex($$[$0 - 4], $$[$0 - 2], 'square');
                break;
            case 45:
                this.$ = $$[$0 - 5];yy.addVertex($$[$0 - 5], $$[$0 - 2], 'circle');
                break;
            case 46:
                this.$ = $$[$0 - 6];yy.addVertex($$[$0 - 6], $$[$0 - 3], 'circle');
                break;
            case 47:
                this.$ = $$[$0 - 3];yy.addVertex($$[$0 - 3], $$[$0 - 1], 'ellipse');
                break;
            case 48:
                this.$ = $$[$0 - 4];yy.addVertex($$[$0 - 4], $$[$0 - 2], 'ellipse');
                break;
            case 49:
                this.$ = $$[$0 - 3];yy.addVertex($$[$0 - 3], $$[$0 - 1], 'round');
                break;
            case 50:
                this.$ = $$[$0 - 4];yy.addVertex($$[$0 - 4], $$[$0 - 2], 'round');
                break;
            case 51:
                this.$ = $$[$0 - 3];yy.addVertex($$[$0 - 3], $$[$0 - 1], 'diamond');
                break;
            case 52:
                this.$ = $$[$0 - 4];yy.addVertex($$[$0 - 4], $$[$0 - 2], 'diamond');
                break;
            case 53:
                this.$ = $$[$0 - 3];yy.addVertex($$[$0 - 3], $$[$0 - 1], 'odd');
                break;
            case 54:
                this.$ = $$[$0 - 4];yy.addVertex($$[$0 - 4], $$[$0 - 2], 'odd');
                break;
            case 55:
                this.$ = $$[$0];yy.addVertex($$[$0]);
                break;
            case 56:
                this.$ = $$[$0 - 1];yy.addVertex($$[$0 - 1]);
                break;
            case 58:case 93:case 96:case 109:
                this.$ = $$[$0 - 1] + '' + $$[$0];
                break;
            case 61:
                this.$ = 'v';
                break;
            case 62:
                this.$ = '-';
                break;
            case 63:
                $$[$0 - 1].text = $$[$0];this.$ = $$[$0 - 1];
                break;
            case 64:case 65:
                $$[$0 - 2].text = $$[$0 - 1];this.$ = $$[$0 - 2];
                break;
            case 66:
                this.$ = $$[$0];
                break;
            case 67:
                this.$ = { "type": "arrow", "stroke": "normal", "text": $$[$0 - 1] };
                break;
            case 68:
                this.$ = { "type": "arrow_circle", "stroke": "normal", "text": $$[$0 - 1] };
                break;
            case 69:
                this.$ = { "type": "arrow_cross", "stroke": "normal", "text": $$[$0 - 1] };
                break;
            case 70:
                this.$ = { "type": "arrow_open", "stroke": "normal", "text": $$[$0 - 1] };
                break;
            case 71:
                this.$ = { "type": "arrow", "stroke": "dotted", "text": $$[$0 - 1] };
                break;
            case 72:
                this.$ = { "type": "arrow_circle", "stroke": "dotted", "text": $$[$0 - 1] };
                break;
            case 73:
                this.$ = { "type": "arrow_cross", "stroke": "dotted", "text": $$[$0 - 1] };
                break;
            case 74:
                this.$ = { "type": "arrow_open", "stroke": "dotted", "text": $$[$0 - 1] };
                break;
            case 75:
                this.$ = { "type": "arrow", "stroke": "thick", "text": $$[$0 - 1] };
                break;
            case 76:
                this.$ = { "type": "arrow_circle", "stroke": "thick", "text": $$[$0 - 1] };
                break;
            case 77:
                this.$ = { "type": "arrow_cross", "stroke": "thick", "text": $$[$0 - 1] };
                break;
            case 78:
                this.$ = { "type": "arrow_open", "stroke": "thick", "text": $$[$0 - 1] };
                break;
            case 79:
                this.$ = { "type": "arrow", "stroke": "normal" };
                break;
            case 80:
                this.$ = { "type": "arrow_circle", "stroke": "normal" };
                break;
            case 81:
                this.$ = { "type": "arrow_cross", "stroke": "normal" };
                break;
            case 82:
                this.$ = { "type": "arrow_open", "stroke": "normal" };
                break;
            case 83:
                this.$ = { "type": "arrow", "stroke": "dotted" };
                break;
            case 84:
                this.$ = { "type": "arrow_circle", "stroke": "dotted" };
                break;
            case 85:
                this.$ = { "type": "arrow_cross", "stroke": "dotted" };
                break;
            case 86:
                this.$ = { "type": "arrow_open", "stroke": "dotted" };
                break;
            case 87:
                this.$ = { "type": "arrow", "stroke": "thick" };
                break;
            case 88:
                this.$ = { "type": "arrow_circle", "stroke": "thick" };
                break;
            case 89:
                this.$ = { "type": "arrow_cross", "stroke": "thick" };
                break;
            case 90:
                this.$ = { "type": "arrow_open", "stroke": "thick" };
                break;
            case 91:
                this.$ = $$[$0 - 1];
                break;
            case 110:case 111:
                this.$ = $$[$0 - 4];yy.addClass($$[$0 - 2], $$[$0]);
                break;
            case 112:
                this.$ = $$[$0 - 4];yy.setClass($$[$0 - 2], $$[$0]);
                break;
            case 113:
                this.$ = $$[$0 - 4];yy.setClickEvent($$[$0 - 2], $$[$0], undefined, undefined);
                break;
            case 114:
                this.$ = $$[$0 - 6];yy.setClickEvent($$[$0 - 4], $$[$0 - 2], undefined, $$[$0]);
                break;
            case 115:
                this.$ = $$[$0 - 4];yy.setClickEvent($$[$0 - 2], undefined, $$[$0], undefined);
                break;
            case 116:
                this.$ = $$[$0 - 6];yy.setClickEvent($$[$0 - 4], undefined, $$[$0 - 2], $$[$0]);
                break;
            case 117:
                this.$ = $$[$0 - 4];yy.addVertex($$[$0 - 2], undefined, undefined, $$[$0]);
                break;
            case 118:case 119:case 120:
                this.$ = $$[$0 - 4];yy.updateLink($$[$0 - 2], $$[$0]);
                break;
            case 121:case 122:
                this.$ = $$[$0 - 8];yy.updateLinkInterpolate($$[$0 - 6], $$[$0 - 2]);yy.updateLink($$[$0 - 6], $$[$0]);
                break;
            case 123:case 124:
                this.$ = $$[$0 - 6];yy.updateLinkInterpolate($$[$0 - 4], $$[$0]);
                break;
            case 126:
                this.$ = [$$[$0]];
                break;
            case 127:
                $$[$0 - 2].push($$[$0]);this.$ = $$[$0 - 2];
                break;
            case 129:
                this.$ = $$[$0 - 1] + $$[$0];
                break;
        }
    },
    table: [{ 3: 1, 4: 2, 9: $V0, 10: $V1, 12: $V2 }, { 1: [3] }, o($V3, $V4, { 5: 6 }), { 4: 7, 9: $V0, 10: $V1, 12: $V2 }, { 4: 8, 9: $V0, 10: $V1, 12: $V2 }, { 10: [1, 9] }, { 1: [2, 1], 6: 10, 7: 11, 8: $V5, 9: $V6, 10: $V7, 11: $V8, 13: $V9, 18: $Va, 23: 16, 25: 17, 26: 18, 27: 19, 28: 20, 29: 21, 30: $Vb, 33: 23, 35: 29, 44: 30, 45: 32, 46: $Vc, 71: $Vd, 72: $Ve, 73: $Vf, 74: $Vg, 75: $Vh, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, o($V3, [2, 9]), o($V3, [2, 10]), { 13: [1, 46], 15: [1, 47], 16: [1, 48], 17: [1, 49], 18: [1, 50] }, o($Vt, [2, 3]), o($Vt, [2, 4]), o($Vt, [2, 5]), o($Vt, [2, 6]), o($Vt, [2, 7]), o($Vt, [2, 8]), { 8: $Vu, 9: $Vv, 11: $Vw, 24: 51 }, { 8: $Vu, 9: $Vv, 11: $Vw, 24: 55 }, { 8: $Vu, 9: $Vv, 11: $Vw, 24: 56 }, { 8: $Vu, 9: $Vv, 11: $Vw, 24: 57 }, { 8: $Vu, 9: $Vv, 11: $Vw, 24: 58 }, { 8: $Vu, 9: $Vv, 11: $Vw, 24: 59 }, { 8: $Vu, 9: $Vv, 10: $Vx, 11: $Vw, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 24: 61, 30: $VE, 31: 60, 32: $VF, 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 62, 67: $VJ, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, o($VR, [2, 42], { 34: 86, 47: 87, 50: [1, 88], 51: [1, 91], 52: [1, 92], 53: [1, 93], 54: [1, 94], 55: [1, 89], 56: [1, 95], 57: [1, 96], 58: [1, 97], 59: [1, 98], 60: [1, 90], 61: [1, 99], 62: [1, 100], 63: [1, 101], 64: [1, 102] }), { 10: [1, 103] }, { 10: [1, 104] }, { 10: [1, 105] }, { 10: [1, 106] }, { 10: [1, 107] }, o($VS, [2, 55], { 45: 32, 21: 113, 44: 114, 10: $VT, 13: $V9, 15: [1, 112], 18: $Va, 36: [1, 108], 38: [1, 109], 40: [1, 110], 42: [1, 111], 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }), o($VU, [2, 57]), o($VU, [2, 59]), o($VU, [2, 60]), o($VU, [2, 61]), o($VU, [2, 62]), o($VV, [2, 154]), o($VV, [2, 155]), o($VV, [2, 156]), o($VV, [2, 157]), o($VV, [2, 158]), o($VV, [2, 159]), o($VV, [2, 160]), o($VV, [2, 161]), o($VV, [2, 162]), o($VV, [2, 163]), o($VV, [2, 164]), { 8: $VW, 9: $VX, 10: $VT, 14: 116, 21: 119 }, { 8: $VW, 9: $VX, 10: $VT, 14: 120, 21: 119 }, { 8: $VW, 9: $VX, 10: $VT, 14: 121, 21: 119 }, { 8: $VW, 9: $VX, 10: $VT, 14: 122, 21: 119 }, { 8: $VW, 9: $VX, 10: $VT, 14: 123, 21: 119 }, o($Vt, [2, 30]), o($Vt, [2, 38]), o($Vt, [2, 39]), o($Vt, [2, 40]), o($Vt, [2, 31]), o($Vt, [2, 32]), o($Vt, [2, 33]), o($Vt, [2, 34]), o($Vt, [2, 35]), { 8: $Vu, 9: $Vv, 10: $Vx, 11: $Vw, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 24: 124, 30: $VE, 32: $VF, 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 125, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, o($VY, $V4, { 5: 126 }), o($VZ, [2, 92]), o($VZ, [2, 94]), o($VZ, [2, 143]), o($VZ, [2, 144]), o($VZ, [2, 145]), o($VZ, [2, 146]), o($VZ, [2, 147]), o($VZ, [2, 148]), o($VZ, [2, 149]), o($VZ, [2, 150]), o($VZ, [2, 151]), o($VZ, [2, 152]), o($VZ, [2, 153]), o($VZ, [2, 97]), o($VZ, [2, 98]), o($VZ, [2, 99]), o($VZ, [2, 100]), o($VZ, [2, 101]), o($VZ, [2, 102]), o($VZ, [2, 103]), o($VZ, [2, 104]), o($VZ, [2, 105]), o($VZ, [2, 106]), o($VZ, [2, 107]), { 13: $V9, 18: $Va, 33: 127, 35: 29, 44: 30, 45: 32, 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, o($V_, [2, 66], { 48: 128, 49: [1, 129], 65: [1, 130] }), { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 31: 131, 32: $VF, 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 62, 67: $VJ, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 31: 132, 32: $VF, 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 62, 67: $VJ, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 31: 133, 32: $VF, 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 62, 67: $VJ, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, o($V$, [2, 79]), o($V$, [2, 80]), o($V$, [2, 81]), o($V$, [2, 82]), o($V$, [2, 83]), o($V$, [2, 84]), o($V$, [2, 85]), o($V$, [2, 86]), o($V$, [2, 87]), o($V$, [2, 88]), o($V$, [2, 89]), o($V$, [2, 90]), { 13: $V9, 18: $Va, 35: 134, 44: 30, 45: 32, 46: $Vc, 80: [1, 135], 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 78: [1, 136], 81: [1, 137] }, { 13: $V9, 18: $Va, 35: 139, 44: 30, 45: 32, 46: $Vc, 78: [1, 138], 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 13: $V9, 18: $Va, 35: 140, 44: 30, 45: 32, 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 13: $V9, 18: $Va, 35: 141, 44: 30, 45: 32, 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 31: 142, 32: $VF, 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 62, 67: $VJ, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 31: 144, 32: $VF, 38: [1, 143], 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 62, 67: $VJ, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 31: 145, 32: $VF, 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 62, 67: $VJ, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 31: 146, 32: $VF, 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 62, 67: $VJ, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 31: 147, 32: $VF, 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 62, 67: $VJ, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, o($VS, [2, 56]), o($VU, [2, 58]), o($VS, [2, 29], { 21: 148, 10: $VT }), o($V3, [2, 11]), o($V3, [2, 21]), o($V3, [2, 22]), { 9: [1, 149] }, o($V3, [2, 12]), o($V3, [2, 13]), o($V3, [2, 14]), o($V3, [2, 15]), o($VY, $V4, { 5: 150 }), o($VZ, [2, 93]), { 6: 10, 7: 11, 8: $V5, 9: $V6, 10: $V7, 11: $V8, 13: $V9, 18: $Va, 23: 16, 25: 17, 26: 18, 27: 19, 28: 20, 29: 21, 30: $Vb, 32: [1, 151], 33: 23, 35: 29, 44: 30, 45: 32, 46: $Vc, 71: $Vd, 72: $Ve, 73: $Vf, 74: $Vg, 75: $Vh, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, o($VR, [2, 41]), o($V_, [2, 63], { 10: [1, 152] }), { 10: [1, 153] }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 31: 154, 32: $VF, 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 62, 67: $VJ, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 32: $VF, 45: 71, 46: $VG, 50: $VH, 51: [1, 155], 52: [1, 156], 53: [1, 157], 54: [1, 158], 60: $VI, 66: 125, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 32: $VF, 45: 71, 46: $VG, 50: $VH, 56: [1, 159], 57: [1, 160], 58: [1, 161], 59: [1, 162], 60: $VI, 66: 125, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 32: $VF, 45: 71, 46: $VG, 50: $VH, 60: $VI, 61: [1, 163], 62: [1, 164], 63: [1, 165], 64: [1, 166], 66: 125, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: [1, 167], 13: $V9, 18: $Va, 44: 114, 45: 32, 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: [1, 168] }, { 10: [1, 169] }, { 10: [1, 170] }, { 10: [1, 171] }, { 10: [1, 172], 13: $V9, 18: $Va, 44: 114, 45: 32, 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: [1, 173], 13: $V9, 18: $Va, 44: 114, 45: 32, 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: [1, 174], 13: $V9, 18: $Va, 44: 114, 45: 32, 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 32: $VF, 37: [1, 175], 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 125, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 31: 176, 32: $VF, 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 62, 67: $VJ, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 32: $VF, 39: [1, 177], 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 125, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 32: $VF, 41: [1, 178], 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 125, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 32: $VF, 43: [1, 179], 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 125, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 32: $VF, 37: [1, 180], 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 125, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, o($VS, [2, 28]), o($V3, [2, 23]), { 6: 10, 7: 11, 8: $V5, 9: $V6, 10: $V7, 11: $V8, 13: $V9, 18: $Va, 23: 16, 25: 17, 26: 18, 27: 19, 28: 20, 29: 21, 30: $Vb, 32: [1, 181], 33: 23, 35: 29, 44: 30, 45: 32, 46: $Vc, 71: $Vd, 72: $Ve, 73: $Vf, 74: $Vg, 75: $Vh, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, o($Vt, [2, 37]), o($V_, [2, 65]), o($V_, [2, 64]), { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 32: $VF, 45: 71, 46: $VG, 50: $VH, 60: $VI, 65: [1, 182], 66: 125, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, o($V_, [2, 67]), o($V_, [2, 68]), o($V_, [2, 69]), o($V_, [2, 70]), o($V_, [2, 71]), o($V_, [2, 72]), o($V_, [2, 73]), o($V_, [2, 74]), o($V_, [2, 75]), o($V_, [2, 76]), o($V_, [2, 77]), o($V_, [2, 78]), { 10: $V01, 46: $V11, 71: $V21, 79: 183, 80: $V31, 81: $V41, 84: $V51, 85: 184, 87: 185, 88: $V61, 89: $V71, 90: $V81, 91: $V91, 92: $Va1 }, { 10: $V01, 46: $V11, 71: $V21, 79: 197, 80: $V31, 81: $V41, 84: $V51, 85: 184, 87: 185, 88: $V61, 89: $V71, 90: $V81, 91: $V91, 92: $Va1 }, { 10: $V01, 46: $V11, 71: $V21, 79: 198, 80: $V31, 81: $V41, 82: [1, 199], 84: $V51, 85: 184, 87: 185, 88: $V61, 89: $V71, 90: $V81, 91: $V91, 92: $Va1 }, { 10: $V01, 46: $V11, 71: $V21, 79: 200, 80: $V31, 81: $V41, 82: [1, 201], 84: $V51, 85: 184, 87: 185, 88: $V61, 89: $V71, 90: $V81, 91: $V91, 92: $Va1 }, { 10: $V01, 46: $V11, 71: $V21, 79: 202, 80: $V31, 81: $V41, 84: $V51, 85: 184, 87: 185, 88: $V61, 89: $V71, 90: $V81, 91: $V91, 92: $Va1 }, { 10: $V01, 46: $V11, 71: $V21, 79: 203, 80: $V31, 81: $V41, 84: $V51, 85: 184, 87: 185, 88: $V61, 89: $V71, 90: $V81, 91: $V91, 92: $Va1 }, { 13: $V9, 18: $Va, 35: 204, 44: 30, 45: 32, 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 13: $V9, 18: $Va, 35: 205, 44: 30, 45: 32, 46: $Vc, 67: [1, 206], 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, o($VS, [2, 43], { 21: 207, 10: $VT }), { 10: $Vx, 12: $Vy, 13: $Vz, 15: $VA, 16: $VB, 17: $VC, 18: $VD, 30: $VE, 32: $VF, 39: [1, 208], 45: 71, 46: $VG, 50: $VH, 60: $VI, 66: 125, 70: 74, 71: $VK, 72: $VL, 73: $VM, 74: $VN, 75: $VO, 77: 64, 78: $VP, 81: $Vi, 84: $VQ, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, o($VS, [2, 49], { 21: 209, 10: $VT }), o($VS, [2, 47], { 21: 210, 10: $VT }), o($VS, [2, 51], { 21: 211, 10: $VT }), o($VS, [2, 53], { 21: 212, 10: $VT }), o($Vt, [2, 36]), o([10, 13, 18, 46, 81, 86, 88, 89, 91, 92, 94, 95, 96, 97, 98], [2, 91]), o($VR, [2, 117], { 86: $Vb1 }), o($Vc1, [2, 126], { 87: 214, 10: $V01, 46: $V11, 71: $V21, 80: $V31, 81: $V41, 84: $V51, 88: $V61, 89: $V71, 90: $V81, 91: $V91, 92: $Va1 }), o($Vd1, [2, 128]), o($Vd1, [2, 130]), o($Vd1, [2, 131]), o($Vd1, [2, 132]), o($Vd1, [2, 133]), o($Vd1, [2, 134]), o($Vd1, [2, 135]), o($Vd1, [2, 136]), o($Vd1, [2, 137]), o($Vd1, [2, 138]), o($Vd1, [2, 139]), o($Vd1, [2, 140]), o($VR, [2, 118], { 86: $Vb1 }), o($VR, [2, 119], { 86: $Vb1 }), { 10: [1, 215] }, o($VR, [2, 120], { 86: $Vb1 }), { 10: [1, 216] }, o($VR, [2, 110], { 86: $Vb1 }), o($VR, [2, 111], { 86: $Vb1 }), o($VR, [2, 112], { 45: 32, 44: 114, 13: $V9, 18: $Va, 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }), o($VR, [2, 113], { 45: 32, 44: 114, 10: [1, 217], 13: $V9, 18: $Va, 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }), o($VR, [2, 115], { 10: [1, 218] }), o($VS, [2, 44]), { 39: [1, 219] }, o($VS, [2, 50]), o($VS, [2, 48]), o($VS, [2, 52]), o($VS, [2, 54]), { 10: $V01, 46: $V11, 71: $V21, 80: $V31, 81: $V41, 84: $V51, 85: 220, 87: 185, 88: $V61, 89: $V71, 90: $V81, 91: $V91, 92: $Va1 }, o($Vd1, [2, 129]), { 13: $V9, 18: $Va, 35: 221, 44: 30, 45: 32, 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 13: $V9, 18: $Va, 35: 222, 44: 30, 45: 32, 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }, { 67: [1, 223] }, { 67: [1, 224] }, o($VS, [2, 45], { 21: 225, 10: $VT }), o($Vc1, [2, 127], { 87: 214, 10: $V01, 46: $V11, 71: $V21, 80: $V31, 81: $V41, 84: $V51, 88: $V61, 89: $V71, 90: $V81, 91: $V91, 92: $Va1 }), o($VR, [2, 123], { 45: 32, 44: 114, 10: [1, 226], 13: $V9, 18: $Va, 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }), o($VR, [2, 124], { 45: 32, 44: 114, 10: [1, 227], 13: $V9, 18: $Va, 46: $Vc, 81: $Vi, 86: $Vj, 88: $Vk, 89: $Vl, 91: $Vm, 92: $Vn, 94: $Vo, 95: $Vp, 96: $Vq, 97: $Vr, 98: $Vs }), o($VR, [2, 114]), o($VR, [2, 116]), o($VS, [2, 46]), { 10: $V01, 46: $V11, 71: $V21, 79: 228, 80: $V31, 81: $V41, 84: $V51, 85: 184, 87: 185, 88: $V61, 89: $V71, 90: $V81, 91: $V91, 92: $Va1 }, { 10: $V01, 46: $V11, 71: $V21, 79: 229, 80: $V31, 81: $V41, 84: $V51, 85: 184, 87: 185, 88: $V61, 89: $V71, 90: $V81, 91: $V91, 92: $Va1 }, o($VR, [2, 121], { 86: $Vb1 }), o($VR, [2, 122], { 86: $Vb1 })],
    defaultActions: {},
    parseError: function parseError(str, hash) {
        if (hash.recoverable) {
            this.trace(str);
        } else {
            var _parseError = function _parseError(msg, hash) {
                this.message = msg;
                this.hash = hash;
            };

            _parseError.prototype = Error;

            throw new _parseError(str, hash);
        }
    },
    parse: function parse(input) {
        var self = this,
            stack = [0],
            tstack = [],
            vstack = [null],
            lstack = [],
            table = this.table,
            yytext = '',
            yylineno = 0,
            yyleng = 0,
            recovering = 0,
            TERROR = 2,
            EOF = 1;
        var args = lstack.slice.call(arguments, 1);
        var lexer = Object.create(this.lexer);
        var sharedState = { yy: {} };
        for (var k in this.yy) {
            if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
                sharedState.yy[k] = this.yy[k];
            }
        }
        lexer.setInput(input, sharedState.yy);
        sharedState.yy.lexer = lexer;
        sharedState.yy.parser = this;
        if (typeof lexer.yylloc == 'undefined') {
            lexer.yylloc = {};
        }
        var yyloc = lexer.yylloc;
        lstack.push(yyloc);
        var ranges = lexer.options && lexer.options.ranges;
        if (typeof sharedState.yy.parseError === 'function') {
            this.parseError = sharedState.yy.parseError;
        } else {
            this.parseError = Object.getPrototypeOf(this).parseError;
        }
        function popStack(n) {
            stack.length = stack.length - 2 * n;
            vstack.length = vstack.length - n;
            lstack.length = lstack.length - n;
        }
        function lex() {
            var token;
            token = tstack.pop() || lexer.lex() || EOF;
            if (typeof token !== 'number') {
                if (token instanceof Array) {
                    tstack = token;
                    token = tstack.pop();
                }
                token = self.symbols_[token] || token;
            }
            return token;
        }
        var symbol,
            preErrorSymbol,
            state,
            action,
            a,
            r,
            yyval = {},
            p,
            len,
            newState,
            expected;
        while (true) {
            state = stack[stack.length - 1];
            if (this.defaultActions[state]) {
                action = this.defaultActions[state];
            } else {
                if (symbol === null || typeof symbol == 'undefined') {
                    symbol = lex();
                }
                action = table[state] && table[state][symbol];
            }
            if (typeof action === 'undefined' || !action.length || !action[0]) {
                var errStr = '';
                expected = [];
                for (p in table[state]) {
                    if (this.terminals_[p] && p > TERROR) {
                        expected.push('\'' + this.terminals_[p] + '\'');
                    }
                }
                if (lexer.showPosition) {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
                } else {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
                }
                this.parseError(errStr, {
                    text: lexer.match,
                    token: this.terminals_[symbol] || symbol,
                    line: lexer.yylineno,
                    loc: yyloc,
                    expected: expected
                });
            }
            if (action[0] instanceof Array && action.length > 1) {
                throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
            }
            switch (action[0]) {
                case 1:
                    stack.push(symbol);
                    vstack.push(lexer.yytext);
                    lstack.push(lexer.yylloc);
                    stack.push(action[1]);
                    symbol = null;
                    if (!preErrorSymbol) {
                        yyleng = lexer.yyleng;
                        yytext = lexer.yytext;
                        yylineno = lexer.yylineno;
                        yyloc = lexer.yylloc;
                        if (recovering > 0) {
                            recovering--;
                        }
                    } else {
                        symbol = preErrorSymbol;
                        preErrorSymbol = null;
                    }
                    break;
                case 2:
                    len = this.productions_[action[1]][1];
                    yyval.$ = vstack[vstack.length - len];
                    yyval._$ = {
                        first_line: lstack[lstack.length - (len || 1)].first_line,
                        last_line: lstack[lstack.length - 1].last_line,
                        first_column: lstack[lstack.length - (len || 1)].first_column,
                        last_column: lstack[lstack.length - 1].last_column
                    };
                    if (ranges) {
                        yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
                    }
                    r = this.performAction.apply(yyval, [yytext, yyleng, yylineno, sharedState.yy, action[1], vstack, lstack].concat(args));
                    if (typeof r !== 'undefined') {
                        return r;
                    }
                    if (len) {
                        stack = stack.slice(0, -1 * len * 2);
                        vstack = vstack.slice(0, -1 * len);
                        lstack = lstack.slice(0, -1 * len);
                    }
                    stack.push(this.productions_[action[1]][0]);
                    vstack.push(yyval.$);
                    lstack.push(yyval._$);
                    newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
                    stack.push(newState);
                    break;
                case 3:
                    return true;
            }
        }
        return true;
    } };

/* generated by jison-lex 0.3.4 */
var lexer = function () {
    var lexer = {

        EOF: 1,

        parseError: function parseError(str, hash) {
            if (this.yy.parser) {
                this.yy.parser.parseError(str, hash);
            } else {
                throw new Error(str);
            }
        },

        // resets the lexer, sets new input
        setInput: function setInput(input, yy) {
            this.yy = yy || this.yy || {};
            this._input = input;
            this._more = this._backtrack = this.done = false;
            this.yylineno = this.yyleng = 0;
            this.yytext = this.matched = this.match = '';
            this.conditionStack = ['INITIAL'];
            this.yylloc = {
                first_line: 1,
                first_column: 0,
                last_line: 1,
                last_column: 0
            };
            if (this.options.ranges) {
                this.yylloc.range = [0, 0];
            }
            this.offset = 0;
            return this;
        },

        // consumes and returns one char from the input
        input: function input() {
            var ch = this._input[0];
            this.yytext += ch;
            this.yyleng++;
            this.offset++;
            this.match += ch;
            this.matched += ch;
            var lines = ch.match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno++;
                this.yylloc.last_line++;
            } else {
                this.yylloc.last_column++;
            }
            if (this.options.ranges) {
                this.yylloc.range[1]++;
            }

            this._input = this._input.slice(1);
            return ch;
        },

        // unshifts one char (or a string) into the input
        unput: function unput(ch) {
            var len = ch.length;
            var lines = ch.split(/(?:\r\n?|\n)/g);

            this._input = ch + this._input;
            this.yytext = this.yytext.substr(0, this.yytext.length - len);
            //this.yyleng -= len;
            this.offset -= len;
            var oldLines = this.match.split(/(?:\r\n?|\n)/g);
            this.match = this.match.substr(0, this.match.length - 1);
            this.matched = this.matched.substr(0, this.matched.length - 1);

            if (lines.length - 1) {
                this.yylineno -= lines.length - 1;
            }
            var r = this.yylloc.range;

            this.yylloc = {
                first_line: this.yylloc.first_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.first_column,
                last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
            };

            if (this.options.ranges) {
                this.yylloc.range = [r[0], r[0] + this.yyleng - len];
            }
            this.yyleng = this.yytext.length;
            return this;
        },

        // When called from action, caches matched text and appends it on next action
        more: function more() {
            this._more = true;
            return this;
        },

        // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
        reject: function reject() {
            if (this.options.backtrack_lexer) {
                this._backtrack = true;
            } else {
                return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
            }
            return this;
        },

        // retain first n characters of the match
        less: function less(n) {
            this.unput(this.match.slice(n));
        },

        // displays already matched input, i.e. for error messages
        pastInput: function pastInput() {
            var past = this.matched.substr(0, this.matched.length - this.match.length);
            return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, "");
        },

        // displays upcoming input, i.e. for error messages
        upcomingInput: function upcomingInput() {
            var next = this.match;
            if (next.length < 20) {
                next += this._input.substr(0, 20 - next.length);
            }
            return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
        },

        // displays the character position where the lexing error occurred, i.e. for error messages
        showPosition: function showPosition() {
            var pre = this.pastInput();
            var c = new Array(pre.length + 1).join("-");
            return pre + this.upcomingInput() + "\n" + c + "^";
        },

        // test the lexed token: return FALSE when not a match, otherwise return token
        test_match: function test_match(match, indexed_rule) {
            var token, lines, backup;

            if (this.options.backtrack_lexer) {
                // save context
                backup = {
                    yylineno: this.yylineno,
                    yylloc: {
                        first_line: this.yylloc.first_line,
                        last_line: this.last_line,
                        first_column: this.yylloc.first_column,
                        last_column: this.yylloc.last_column
                    },
                    yytext: this.yytext,
                    match: this.match,
                    matches: this.matches,
                    matched: this.matched,
                    yyleng: this.yyleng,
                    offset: this.offset,
                    _more: this._more,
                    _input: this._input,
                    yy: this.yy,
                    conditionStack: this.conditionStack.slice(0),
                    done: this.done
                };
                if (this.options.ranges) {
                    backup.yylloc.range = this.yylloc.range.slice(0);
                }
            }

            lines = match[0].match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno += lines.length;
            }
            this.yylloc = {
                first_line: this.yylloc.last_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.last_column,
                last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
            };
            this.yytext += match[0];
            this.match += match[0];
            this.matches = match;
            this.yyleng = this.yytext.length;
            if (this.options.ranges) {
                this.yylloc.range = [this.offset, this.offset += this.yyleng];
            }
            this._more = false;
            this._backtrack = false;
            this._input = this._input.slice(match[0].length);
            this.matched += match[0];
            token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
            if (this.done && this._input) {
                this.done = false;
            }
            if (token) {
                return token;
            } else if (this._backtrack) {
                // recover context
                for (var k in backup) {
                    this[k] = backup[k];
                }
                return false; // rule action called reject() implying the next rule should be tested instead.
            }
            return false;
        },

        // return next match in input
        next: function next() {
            if (this.done) {
                return this.EOF;
            }
            if (!this._input) {
                this.done = true;
            }

            var token, match, tempMatch, index;
            if (!this._more) {
                this.yytext = '';
                this.match = '';
            }
            var rules = this._currentRules();
            for (var i = 0; i < rules.length; i++) {
                tempMatch = this._input.match(this.rules[rules[i]]);
                if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                    match = tempMatch;
                    index = i;
                    if (this.options.backtrack_lexer) {
                        token = this.test_match(tempMatch, rules[i]);
                        if (token !== false) {
                            return token;
                        } else if (this._backtrack) {
                            match = false;
                            continue; // rule action called reject() implying a rule MISmatch.
                        } else {
                            // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                            return false;
                        }
                    } else if (!this.options.flex) {
                        break;
                    }
                }
            }
            if (match) {
                token = this.test_match(match, rules[index]);
                if (token !== false) {
                    return token;
                }
                // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                return false;
            }
            if (this._input === "") {
                return this.EOF;
            } else {
                return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
            }
        },

        // return next match that has a token
        lex: function lex() {
            var r = this.next();
            if (r) {
                return r;
            } else {
                return this.lex();
            }
        },

        // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
        begin: function begin(condition) {
            this.conditionStack.push(condition);
        },

        // pop the previously active lexer condition state off the condition stack
        popState: function popState() {
            var n = this.conditionStack.length - 1;
            if (n > 0) {
                return this.conditionStack.pop();
            } else {
                return this.conditionStack[0];
            }
        },

        // produce the lexer rule set which is active for the currently active lexer condition state
        _currentRules: function _currentRules() {
            if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
                return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
            } else {
                return this.conditions["INITIAL"].rules;
            }
        },

        // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
        topState: function topState(n) {
            n = this.conditionStack.length - 1 - Math.abs(n || 0);
            if (n >= 0) {
                return this.conditionStack[n];
            } else {
                return "INITIAL";
            }
        },

        // alias for begin(condition)
        pushState: function pushState(condition) {
            this.begin(condition);
        },

        // return the number of states currently on the stack
        stateStackSize: function stateStackSize() {
            return this.conditionStack.length;
        },
        options: {},
        performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
            var YYSTATE = YY_START;
            switch ($avoiding_name_collisions) {
                case 0:
                    /* do nothing */
                    break;
                case 1:
                    this.begin("string");
                    break;
                case 2:
                    this.popState();
                    break;
                case 3:
                    return "STR";
                    break;
                case 4:
                    return 71;
                    break;
                case 5:
                    return 78;
                    break;
                case 6:
                    return 72;
                    break;
                case 7:
                    return 82;
                    break;
                case 8:
                    return 73;
                    break;
                case 9:
                    return 74;
                    break;
                case 10:
                    return 75;
                    break;
                case 11:
                    return 12;
                    break;
                case 12:
                    return 30;
                    break;
                case 13:
                    return 32;
                    break;
                case 14:
                    return 13;
                    break;
                case 15:
                    return 13;
                    break;
                case 16:
                    return 13;
                    break;
                case 17:
                    return 13;
                    break;
                case 18:
                    return 13;
                    break;
                case 19:
                    return 13;
                    break;
                case 20:
                    return 81;
                    break;
                case 21:
                    return 91;
                    break;
                case 22:
                    return 89;
                    break;
                case 23:
                    return 8;
                    break;
                case 24:
                    return 86;
                    break;
                case 25:
                    return 98;
                    break;
                case 26:
                    return 16;
                    break;
                case 27:
                    return 15;
                    break;
                case 28:
                    return 17;
                    break;
                case 29:
                    return 18;
                    break;
                case 30:
                    return 53;
                    break;
                case 31:
                    return 51;
                    break;
                case 32:
                    return 52;
                    break;
                case 33:
                    return 54;
                    break;
                case 34:
                    return 58;
                    break;
                case 35:
                    return 56;
                    break;
                case 36:
                    return 57;
                    break;
                case 37:
                    return 59;
                    break;
                case 38:
                    return 58;
                    break;
                case 39:
                    return 56;
                    break;
                case 40:
                    return 57;
                    break;
                case 41:
                    return 59;
                    break;
                case 42:
                    return 63;
                    break;
                case 43:
                    return 61;
                    break;
                case 44:
                    return 62;
                    break;
                case 45:
                    return 64;
                    break;
                case 46:
                    return 50;
                    break;
                case 47:
                    return 55;
                    break;
                case 48:
                    return 60;
                    break;
                case 49:
                    return 40;
                    break;
                case 50:
                    return 41;
                    break;
                case 51:
                    return 46;
                    break;
                case 52:
                    return 92;
                    break;
                case 53:
                    return 96;
                    break;
                case 54:
                    return 84;
                    break;
                case 55:
                    return 97;
                    break;
                case 56:
                    return 97;
                    break;
                case 57:
                    return 88;
                    break;
                case 58:
                    return 94;
                    break;
                case 59:
                    return 95;
                    break;
                case 60:
                    return 65;
                    break;
                case 61:
                    return 38;
                    break;
                case 62:
                    return 39;
                    break;
                case 63:
                    return 36;
                    break;
                case 64:
                    return 37;
                    break;
                case 65:
                    return 42;
                    break;
                case 66:
                    return 43;
                    break;
                case 67:
                    return 101;
                    break;
                case 68:
                    return 9;
                    break;
                case 69:
                    return 10;
                    break;
                case 70:
                    return 11;
                    break;
            }
        },
        rules: [/^(?:%%[^\n]*)/, /^(?:["])/, /^(?:["])/, /^(?:[^"]*)/, /^(?:style\b)/, /^(?:default\b)/, /^(?:linkStyle\b)/, /^(?:interpolate\b)/, /^(?:classDef\b)/, /^(?:class\b)/, /^(?:click\b)/, /^(?:graph\b)/, /^(?:subgraph\b)/, /^(?:end\b\s*)/, /^(?:LR\b)/, /^(?:RL\b)/, /^(?:TB\b)/, /^(?:BT\b)/, /^(?:TD\b)/, /^(?:BR\b)/, /^(?:[0-9]+)/, /^(?:#)/, /^(?::)/, /^(?:;)/, /^(?:,)/, /^(?:\*)/, /^(?:<)/, /^(?:>)/, /^(?:\^)/, /^(?:v\b)/, /^(?:\s*--[x]\s*)/, /^(?:\s*-->\s*)/, /^(?:\s*--[o]\s*)/, /^(?:\s*---\s*)/, /^(?:\s*-\.-[x]\s*)/, /^(?:\s*-\.->\s*)/, /^(?:\s*-\.-[o]\s*)/, /^(?:\s*-\.-\s*)/, /^(?:\s*.-[x]\s*)/, /^(?:\s*\.->\s*)/, /^(?:\s*\.-[o]\s*)/, /^(?:\s*\.-\s*)/, /^(?:\s*==[x]\s*)/, /^(?:\s*==>\s*)/, /^(?:\s*==[o]\s*)/, /^(?:\s*==[\=]\s*)/, /^(?:\s*--\s*)/, /^(?:\s*-\.\s*)/, /^(?:\s*==\s*)/, /^(?:\(-)/, /^(?:-\))/, /^(?:-)/, /^(?:\.)/, /^(?:\+)/, /^(?:%)/, /^(?:=)/, /^(?:=)/, /^(?:[A-Za-z]+)/, /^(?:[!"#$%&'*+,-.`?\\_\/])/, /^(?:[\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6]|[\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377]|[\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5]|[\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA]|[\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE]|[\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA]|[\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0]|[\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977]|[\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2]|[\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A]|[\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39]|[\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8]|[\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C]|[\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C]|[\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99]|[\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0]|[\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D]|[\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3]|[\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10]|[\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1]|[\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81]|[\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3]|[\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6]|[\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A]|[\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081]|[\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D]|[\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0]|[\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310]|[\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C]|[\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u1700-\u170C\u170E-\u1711]|[\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7]|[\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C]|[\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16]|[\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF]|[\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC]|[\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D]|[\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D]|[\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3]|[\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F]|[\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128]|[\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184]|[\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3]|[\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6]|[\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE]|[\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C]|[\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D]|[\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC]|[\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B]|[\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788]|[\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805]|[\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB]|[\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28]|[\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5]|[\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4]|[\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E]|[\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D]|[\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36]|[\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D]|[\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC]|[\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF]|[\uFFD2-\uFFD7\uFFDA-\uFFDC])/, /^(?:\|)/, /^(?:\()/, /^(?:\))/, /^(?:\[)/, /^(?:\])/, /^(?:\{)/, /^(?:\})/, /^(?:")/, /^(?:\n+)/, /^(?:\s)/, /^(?:$)/],
        conditions: { "string": { "rules": [2, 3], "inclusive": false }, "INITIAL": { "rules": [0, 1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70], "inclusive": true } }
    };
    return lexer;
}();
parser.lexer = lexer;
function Parser() {
    this.yy = {};
}
Parser.prototype = parser;parser.Parser = Parser;
return new Parser();

}();

if (true) {

exports.parser = parser;
exports.Parser = parser.Parser;
exports.parse = function () {
    return parser.parse.apply(parser, arguments);
};
exports.main = function commonjsMain(args) {
    if (!args[1]) {
        console.log('Usage: ' + args[0] + ' FILE');
        process.exit(1);
    }
    var source = __webpack_require__(8).readFileSync(__webpack_require__(9).normalize(args[1]), "utf8");
    return exports.parser.parse(source);
};
if (typeof module !== 'undefined' && __webpack_require__.c[__webpack_require__.s] === module) {
    exports.main(process.argv.slice(1));
}

} /* WEBPACK VAR INJECTION */}.call(exports, webpack_require(7), webpack_require(3)(module)))

/***/ }), /* 157 */ /***/ (function(module, exports, webpack_require) {

“use strict”; /* WEBPACK VAR INJECTION */(function(process, module) {

/* parser generated by jison 0.4.17 */ /*

Returns a Parser object of the following structure:

Parser: {
  yy: {}
}

Parser.prototype: {
  yy: {},
  trace: function(),
  symbols_: {associative list: name ==> number},
  terminals_: {associative list: number ==> name},
  productions_: [...],
  performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
  table: [...],
  defaultActions: {...},
  parseError: function(str, hash),
  parse: function(input),

  lexer: {
      EOF: 1,
      parseError: function(str, hash),
      setInput: function(input),
      input: function(),
      unput: function(str),
      more: function(),
      less: function(n),
      pastInput: function(),
      upcomingInput: function(),
      showPosition: function(),
      test_match: function(regex_match_array, rule_index),
      next: function(),
      lex: function(),
      begin: function(condition),
      popState: function(),
      _currentRules: function(),
      topState: function(),
      pushState: function(condition),

      options: {
          ranges: boolean           (optional: true ==> token location info will include a .range[] member)
          flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
          backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
      },

      performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
      rules: [...],
      conditions: {associative list: name ==> set},
  }
}

token location info (@$, _$, etc.): {
  first_line: n,
  last_line: n,
  first_column: n,
  last_column: n,
  range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
}

the parseError function receives a 'hash' object with these members for lexer and parser errors: {
  text:        (matched text)
  token:       (the produced terminal token, if any)
  line:        (yylineno)
}
while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
  loc:         (yylloc)
  expected:    (string describing the set of expected tokens)
  recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
}

*/ var parser = function () {

var o = function o(k, v, _o, l) {
    for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v) {}return _o;
},
    $V0 = [1, 5],
    $V1 = [1, 6],
    $V2 = [1, 12],
    $V3 = [1, 13],
    $V4 = [1, 14],
    $V5 = [1, 15],
    $V6 = [1, 16],
    $V7 = [1, 17],
    $V8 = [1, 18],
    $V9 = [1, 19],
    $Va = [1, 20],
    $Vb = [1, 21],
    $Vc = [1, 22],
    $Vd = [8, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26],
    $Ve = [1, 37],
    $Vf = [1, 33],
    $Vg = [1, 34],
    $Vh = [1, 35],
    $Vi = [1, 36],
    $Vj = [8, 10, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 28, 32, 37, 39, 40, 45, 57, 58],
    $Vk = [10, 28],
    $Vl = [10, 28, 37, 57, 58],
    $Vm = [2, 49],
    $Vn = [1, 45],
    $Vo = [1, 48],
    $Vp = [1, 49],
    $Vq = [1, 52],
    $Vr = [2, 65],
    $Vs = [1, 65],
    $Vt = [1, 66],
    $Vu = [1, 67],
    $Vv = [1, 68],
    $Vw = [1, 69],
    $Vx = [1, 70],
    $Vy = [1, 71],
    $Vz = [1, 72],
    $VA = [1, 73],
    $VB = [8, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 47],
    $VC = [10, 28, 37];
var parser = { trace: function trace() {},
    yy: {},
    symbols_: { "error": 2, "expressions": 3, "graph": 4, "EOF": 5, "graphStatement": 6, "idStatement": 7, "{": 8, "stmt_list": 9, "}": 10, "strict": 11, "GRAPH": 12, "DIGRAPH": 13, "textNoTags": 14, "textNoTagsToken": 15, "ALPHA": 16, "NUM": 17, "COLON": 18, "PLUS": 19, "EQUALS": 20, "MULT": 21, "DOT": 22, "BRKT": 23, "SPACE": 24, "MINUS": 25, "keywords": 26, "stmt": 27, ";": 28, "node_stmt": 29, "edge_stmt": 30, "attr_stmt": 31, "=": 32, "subgraph": 33, "attr_list": 34, "NODE": 35, "EDGE": 36, "[": 37, "a_list": 38, "]": 39, ",": 40, "edgeRHS": 41, "node_id": 42, "edgeop": 43, "port": 44, ":": 45, "compass_pt": 46, "SUBGRAPH": 47, "n": 48, "ne": 49, "e": 50, "se": 51, "s": 52, "sw": 53, "w": 54, "nw": 55, "c": 56, "ARROW_POINT": 57, "ARROW_OPEN": 58, "$accept": 0, "$end": 1 },
    terminals_: { 2: "error", 5: "EOF", 8: "{", 10: "}", 11: "strict", 12: "GRAPH", 13: "DIGRAPH", 16: "ALPHA", 17: "NUM", 18: "COLON", 19: "PLUS", 20: "EQUALS", 21: "MULT", 22: "DOT", 23: "BRKT", 24: "SPACE", 25: "MINUS", 26: "keywords", 28: ";", 32: "=", 35: "NODE", 36: "EDGE", 37: "[", 39: "]", 40: ",", 45: ":", 47: "SUBGRAPH", 48: "n", 49: "ne", 50: "e", 51: "se", 52: "s", 53: "sw", 54: "w", 55: "nw", 56: "c", 57: "ARROW_POINT", 58: "ARROW_OPEN" },
    productions_: [0, [3, 2], [4, 5], [4, 6], [4, 4], [6, 1], [6, 1], [7, 1], [14, 1], [14, 2], [15, 1], [15, 1], [15, 1], [15, 1], [15, 1], [15, 1], [15, 1], [15, 1], [15, 1], [15, 1], [15, 1], [9, 1], [9, 3], [27, 1], [27, 1], [27, 1], [27, 3], [27, 1], [31, 2], [31, 2], [31, 2], [34, 4], [34, 3], [34, 3], [34, 2], [38, 5], [38, 5], [38, 3], [30, 3], [30, 3], [30, 2], [30, 2], [41, 3], [41, 3], [41, 2], [41, 2], [29, 2], [29, 1], [42, 2], [42, 1], [44, 4], [44, 2], [44, 2], [33, 5], [33, 4], [33, 3], [46, 1], [46, 1], [46, 1], [46, 1], [46, 1], [46, 1], [46, 1], [46, 1], [46, 1], [46, 0], [43, 1], [43, 1]],
    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
        /* this == yyval */

        var $0 = $$.length - 1;
        switch (yystate) {
            case 1:
                this.$ = $$[$0 - 1];
                break;
            case 2:
                this.$ = $$[$0 - 4];
                break;
            case 3:
                this.$ = $$[$0 - 5];
                break;
            case 4:
                this.$ = $$[$0 - 3];
                break;
            case 8:case 10:case 11:
                this.$ = $$[$0];
                break;
            case 9:
                this.$ = $$[$0 - 1] + '' + $$[$0];
                break;
            case 12:case 13:case 14:case 15:case 16:case 18:case 19:case 20:
                this.$ = $$[$0];
                break;
            case 17:
                this.$ = '<br>';
                break;
            case 39:
                this.$ = 'oy';
                break;
            case 40:

                yy.addLink($$[$0 - 1], $$[$0].id, $$[$0].op);
                this.$ = 'oy';
                break;
            case 42:

                yy.addLink($$[$0 - 1], $$[$0].id, $$[$0].op);
                this.$ = { op: $$[$0 - 2], id: $$[$0 - 1] };

                break;
            case 44:

                this.$ = { op: $$[$0 - 1], id: $$[$0] };

                break;
            case 48:
                yy.addVertex($$[$0 - 1]);this.$ = $$[$0 - 1];
                break;
            case 49:
                yy.addVertex($$[$0]);this.$ = $$[$0];
                break;
            case 66:
                this.$ = 'arrow';
                break;
            case 67:
                this.$ = 'arrow_open';
                break;
        }
    },
    table: [{ 3: 1, 4: 2, 6: 3, 11: [1, 4], 12: $V0, 13: $V1 }, { 1: [3] }, { 5: [1, 7] }, { 7: 8, 8: [1, 9], 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc }, { 6: 23, 12: $V0, 13: $V1 }, o($Vd, [2, 5]), o($Vd, [2, 6]), { 1: [2, 1] }, { 8: [1, 24] }, { 7: 30, 8: $Ve, 9: 25, 12: $Vf, 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc, 27: 26, 29: 27, 30: 28, 31: 29, 33: 31, 35: $Vg, 36: $Vh, 42: 32, 47: $Vi }, o([8, 10, 28, 32, 37, 39, 40, 45, 57, 58], [2, 7], { 15: 38, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc }), o($Vj, [2, 8]), o($Vj, [2, 10]), o($Vj, [2, 11]), o($Vj, [2, 12]), o($Vj, [2, 13]), o($Vj, [2, 14]), o($Vj, [2, 15]), o($Vj, [2, 16]), o($Vj, [2, 17]), o($Vj, [2, 18]), o($Vj, [2, 19]), o($Vj, [2, 20]), { 7: 39, 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc }, { 7: 30, 8: $Ve, 9: 40, 12: $Vf, 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc, 27: 26, 29: 27, 30: 28, 31: 29, 33: 31, 35: $Vg, 36: $Vh, 42: 32, 47: $Vi }, { 10: [1, 41] }, { 10: [2, 21], 28: [1, 42] }, o($Vk, [2, 23]), o($Vk, [2, 24]), o($Vk, [2, 25]), o($Vl, $Vm, { 44: 44, 32: [1, 43], 45: $Vn }), o($Vk, [2, 27], { 41: 46, 43: 47, 57: $Vo, 58: $Vp }), o($Vk, [2, 47], { 43: 47, 34: 50, 41: 51, 37: $Vq, 57: $Vo, 58: $Vp }), { 34: 53, 37: $Vq }, { 34: 54, 37: $Vq }, { 34: 55, 37: $Vq }, { 7: 56, 8: [1, 57], 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc }, { 7: 30, 8: $Ve, 9: 58, 12: $Vf, 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc, 27: 26, 29: 27, 30: 28, 31: 29, 33: 31, 35: $Vg, 36: $Vh, 42: 32, 47: $Vi }, o($Vj, [2, 9]), { 8: [1, 59] }, { 10: [1, 60] }, { 5: [2, 4] }, { 7: 30, 8: $Ve, 9: 61, 12: $Vf, 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc, 27: 26, 29: 27, 30: 28, 31: 29, 33: 31, 35: $Vg, 36: $Vh, 42: 32, 47: $Vi }, { 7: 62, 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc }, o($Vl, [2, 48]), o($Vl, $Vr, { 14: 10, 15: 11, 7: 63, 46: 64, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc, 48: $Vs, 49: $Vt, 50: $Vu, 51: $Vv, 52: $Vw, 53: $Vx, 54: $Vy, 55: $Vz, 56: $VA }), o($Vk, [2, 41], { 34: 74, 37: $Vq }), { 7: 77, 8: $Ve, 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc, 33: 76, 42: 75, 47: $Vi }, o($VB, [2, 66]), o($VB, [2, 67]), o($Vk, [2, 46]), o($Vk, [2, 40], { 34: 78, 37: $Vq }), { 7: 81, 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc, 38: 79, 39: [1, 80] }, o($Vk, [2, 28]), o($Vk, [2, 29]), o($Vk, [2, 30]), { 8: [1, 82] }, { 7: 30, 8: $Ve, 9: 83, 12: $Vf, 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc, 27: 26, 29: 27, 30: 28, 31: 29, 33: 31, 35: $Vg, 36: $Vh, 42: 32, 47: $Vi }, { 10: [1, 84] }, { 7: 30, 8: $Ve, 9: 85, 12: $Vf, 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc, 27: 26, 29: 27, 30: 28, 31: 29, 33: 31, 35: $Vg, 36: $Vh, 42: 32, 47: $Vi }, { 5: [2, 2] }, { 10: [2, 22] }, o($Vk, [2, 26]), o($Vl, [2, 51], { 45: [1, 86] }), o($Vl, [2, 52]), o($Vl, [2, 56]), o($Vl, [2, 57]), o($Vl, [2, 58]), o($Vl, [2, 59]), o($Vl, [2, 60]), o($Vl, [2, 61]), o($Vl, [2, 62]), o($Vl, [2, 63]), o($Vl, [2, 64]), o($Vk, [2, 38]), o($VC, [2, 44], { 43: 47, 41: 87, 57: $Vo, 58: $Vp }), o($VC, [2, 45], { 43: 47, 41: 88, 57: $Vo, 58: $Vp }), o($Vl, $Vm, { 44: 44, 45: $Vn }), o($Vk, [2, 39]), { 39: [1, 89] }, o($Vk, [2, 34], { 34: 90, 37: $Vq }), { 32: [1, 91] }, { 7: 30, 8: $Ve, 9: 92, 12: $Vf, 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc, 27: 26, 29: 27, 30: 28, 31: 29, 33: 31, 35: $Vg, 36: $Vh, 42: 32, 47: $Vi }, { 10: [1, 93] }, o($Vl, [2, 55]), { 10: [1, 94] }, o($Vl, $Vr, { 46: 95, 48: $Vs, 49: $Vt, 50: $Vu, 51: $Vv, 52: $Vw, 53: $Vx, 54: $Vy, 55: $Vz, 56: $VA }), o($VC, [2, 42]), o($VC, [2, 43]), o($Vk, [2, 33], { 34: 96, 37: $Vq }), o($Vk, [2, 32]), { 7: 97, 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc }, { 10: [1, 98] }, o($Vl, [2, 54]), { 5: [2, 3] }, o($Vl, [2, 50]), o($Vk, [2, 31]), { 28: [1, 99], 39: [2, 37], 40: [1, 100] }, o($Vl, [2, 53]), { 7: 81, 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc, 38: 101 }, { 7: 81, 14: 10, 15: 11, 16: $V2, 17: $V3, 18: $V4, 19: $V5, 20: $V6, 21: $V7, 22: $V8, 23: $V9, 24: $Va, 25: $Vb, 26: $Vc, 38: 102 }, { 39: [2, 35] }, { 39: [2, 36] }],
    defaultActions: { 7: [2, 1], 41: [2, 4], 60: [2, 2], 61: [2, 22], 94: [2, 3], 101: [2, 35], 102: [2, 36] },
    parseError: function parseError(str, hash) {
        if (hash.recoverable) {
            this.trace(str);
        } else {
            var _parseError = function _parseError(msg, hash) {
                this.message = msg;
                this.hash = hash;
            };

            _parseError.prototype = Error;

            throw new _parseError(str, hash);
        }
    },
    parse: function parse(input) {
        var self = this,
            stack = [0],
            tstack = [],
            vstack = [null],
            lstack = [],
            table = this.table,
            yytext = '',
            yylineno = 0,
            yyleng = 0,
            recovering = 0,
            TERROR = 2,
            EOF = 1;
        var args = lstack.slice.call(arguments, 1);
        var lexer = Object.create(this.lexer);
        var sharedState = { yy: {} };
        for (var k in this.yy) {
            if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
                sharedState.yy[k] = this.yy[k];
            }
        }
        lexer.setInput(input, sharedState.yy);
        sharedState.yy.lexer = lexer;
        sharedState.yy.parser = this;
        if (typeof lexer.yylloc == 'undefined') {
            lexer.yylloc = {};
        }
        var yyloc = lexer.yylloc;
        lstack.push(yyloc);
        var ranges = lexer.options && lexer.options.ranges;
        if (typeof sharedState.yy.parseError === 'function') {
            this.parseError = sharedState.yy.parseError;
        } else {
            this.parseError = Object.getPrototypeOf(this).parseError;
        }
        function popStack(n) {
            stack.length = stack.length - 2 * n;
            vstack.length = vstack.length - n;
            lstack.length = lstack.length - n;
        }
        function lex() {
            var token;
            token = tstack.pop() || lexer.lex() || EOF;
            if (typeof token !== 'number') {
                if (token instanceof Array) {
                    tstack = token;
                    token = tstack.pop();
                }
                token = self.symbols_[token] || token;
            }
            return token;
        }
        var symbol,
            preErrorSymbol,
            state,
            action,
            a,
            r,
            yyval = {},
            p,
            len,
            newState,
            expected;
        while (true) {
            state = stack[stack.length - 1];
            if (this.defaultActions[state]) {
                action = this.defaultActions[state];
            } else {
                if (symbol === null || typeof symbol == 'undefined') {
                    symbol = lex();
                }
                action = table[state] && table[state][symbol];
            }
            if (typeof action === 'undefined' || !action.length || !action[0]) {
                var errStr = '';
                expected = [];
                for (p in table[state]) {
                    if (this.terminals_[p] && p > TERROR) {
                        expected.push('\'' + this.terminals_[p] + '\'');
                    }
                }
                if (lexer.showPosition) {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
                } else {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
                }
                this.parseError(errStr, {
                    text: lexer.match,
                    token: this.terminals_[symbol] || symbol,
                    line: lexer.yylineno,
                    loc: yyloc,
                    expected: expected
                });
            }
            if (action[0] instanceof Array && action.length > 1) {
                throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
            }
            switch (action[0]) {
                case 1:
                    stack.push(symbol);
                    vstack.push(lexer.yytext);
                    lstack.push(lexer.yylloc);
                    stack.push(action[1]);
                    symbol = null;
                    if (!preErrorSymbol) {
                        yyleng = lexer.yyleng;
                        yytext = lexer.yytext;
                        yylineno = lexer.yylineno;
                        yyloc = lexer.yylloc;
                        if (recovering > 0) {
                            recovering--;
                        }
                    } else {
                        symbol = preErrorSymbol;
                        preErrorSymbol = null;
                    }
                    break;
                case 2:
                    len = this.productions_[action[1]][1];
                    yyval.$ = vstack[vstack.length - len];
                    yyval._$ = {
                        first_line: lstack[lstack.length - (len || 1)].first_line,
                        last_line: lstack[lstack.length - 1].last_line,
                        first_column: lstack[lstack.length - (len || 1)].first_column,
                        last_column: lstack[lstack.length - 1].last_column
                    };
                    if (ranges) {
                        yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
                    }
                    r = this.performAction.apply(yyval, [yytext, yyleng, yylineno, sharedState.yy, action[1], vstack, lstack].concat(args));
                    if (typeof r !== 'undefined') {
                        return r;
                    }
                    if (len) {
                        stack = stack.slice(0, -1 * len * 2);
                        vstack = vstack.slice(0, -1 * len);
                        lstack = lstack.slice(0, -1 * len);
                    }
                    stack.push(this.productions_[action[1]][0]);
                    vstack.push(yyval.$);
                    lstack.push(yyval._$);
                    newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
                    stack.push(newState);
                    break;
                case 3:
                    return true;
            }
        }
        return true;
    } };

/* generated by jison-lex 0.3.4 */
var lexer = function () {
    var lexer = {

        EOF: 1,

        parseError: function parseError(str, hash) {
            if (this.yy.parser) {
                this.yy.parser.parseError(str, hash);
            } else {
                throw new Error(str);
            }
        },

        // resets the lexer, sets new input
        setInput: function setInput(input, yy) {
            this.yy = yy || this.yy || {};
            this._input = input;
            this._more = this._backtrack = this.done = false;
            this.yylineno = this.yyleng = 0;
            this.yytext = this.matched = this.match = '';
            this.conditionStack = ['INITIAL'];
            this.yylloc = {
                first_line: 1,
                first_column: 0,
                last_line: 1,
                last_column: 0
            };
            if (this.options.ranges) {
                this.yylloc.range = [0, 0];
            }
            this.offset = 0;
            return this;
        },

        // consumes and returns one char from the input
        input: function input() {
            var ch = this._input[0];
            this.yytext += ch;
            this.yyleng++;
            this.offset++;
            this.match += ch;
            this.matched += ch;
            var lines = ch.match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno++;
                this.yylloc.last_line++;
            } else {
                this.yylloc.last_column++;
            }
            if (this.options.ranges) {
                this.yylloc.range[1]++;
            }

            this._input = this._input.slice(1);
            return ch;
        },

        // unshifts one char (or a string) into the input
        unput: function unput(ch) {
            var len = ch.length;
            var lines = ch.split(/(?:\r\n?|\n)/g);

            this._input = ch + this._input;
            this.yytext = this.yytext.substr(0, this.yytext.length - len);
            //this.yyleng -= len;
            this.offset -= len;
            var oldLines = this.match.split(/(?:\r\n?|\n)/g);
            this.match = this.match.substr(0, this.match.length - 1);
            this.matched = this.matched.substr(0, this.matched.length - 1);

            if (lines.length - 1) {
                this.yylineno -= lines.length - 1;
            }
            var r = this.yylloc.range;

            this.yylloc = {
                first_line: this.yylloc.first_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.first_column,
                last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
            };

            if (this.options.ranges) {
                this.yylloc.range = [r[0], r[0] + this.yyleng - len];
            }
            this.yyleng = this.yytext.length;
            return this;
        },

        // When called from action, caches matched text and appends it on next action
        more: function more() {
            this._more = true;
            return this;
        },

        // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
        reject: function reject() {
            if (this.options.backtrack_lexer) {
                this._backtrack = true;
            } else {
                return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
            }
            return this;
        },

        // retain first n characters of the match
        less: function less(n) {
            this.unput(this.match.slice(n));
        },

        // displays already matched input, i.e. for error messages
        pastInput: function pastInput() {
            var past = this.matched.substr(0, this.matched.length - this.match.length);
            return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, "");
        },

        // displays upcoming input, i.e. for error messages
        upcomingInput: function upcomingInput() {
            var next = this.match;
            if (next.length < 20) {
                next += this._input.substr(0, 20 - next.length);
            }
            return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
        },

        // displays the character position where the lexing error occurred, i.e. for error messages
        showPosition: function showPosition() {
            var pre = this.pastInput();
            var c = new Array(pre.length + 1).join("-");
            return pre + this.upcomingInput() + "\n" + c + "^";
        },

        // test the lexed token: return FALSE when not a match, otherwise return token
        test_match: function test_match(match, indexed_rule) {
            var token, lines, backup;

            if (this.options.backtrack_lexer) {
                // save context
                backup = {
                    yylineno: this.yylineno,
                    yylloc: {
                        first_line: this.yylloc.first_line,
                        last_line: this.last_line,
                        first_column: this.yylloc.first_column,
                        last_column: this.yylloc.last_column
                    },
                    yytext: this.yytext,
                    match: this.match,
                    matches: this.matches,
                    matched: this.matched,
                    yyleng: this.yyleng,
                    offset: this.offset,
                    _more: this._more,
                    _input: this._input,
                    yy: this.yy,
                    conditionStack: this.conditionStack.slice(0),
                    done: this.done
                };
                if (this.options.ranges) {
                    backup.yylloc.range = this.yylloc.range.slice(0);
                }
            }

            lines = match[0].match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno += lines.length;
            }
            this.yylloc = {
                first_line: this.yylloc.last_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.last_column,
                last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
            };
            this.yytext += match[0];
            this.match += match[0];
            this.matches = match;
            this.yyleng = this.yytext.length;
            if (this.options.ranges) {
                this.yylloc.range = [this.offset, this.offset += this.yyleng];
            }
            this._more = false;
            this._backtrack = false;
            this._input = this._input.slice(match[0].length);
            this.matched += match[0];
            token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
            if (this.done && this._input) {
                this.done = false;
            }
            if (token) {
                return token;
            } else if (this._backtrack) {
                // recover context
                for (var k in backup) {
                    this[k] = backup[k];
                }
                return false; // rule action called reject() implying the next rule should be tested instead.
            }
            return false;
        },

        // return next match in input
        next: function next() {
            if (this.done) {
                return this.EOF;
            }
            if (!this._input) {
                this.done = true;
            }

            var token, match, tempMatch, index;
            if (!this._more) {
                this.yytext = '';
                this.match = '';
            }
            var rules = this._currentRules();
            for (var i = 0; i < rules.length; i++) {
                tempMatch = this._input.match(this.rules[rules[i]]);
                if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                    match = tempMatch;
                    index = i;
                    if (this.options.backtrack_lexer) {
                        token = this.test_match(tempMatch, rules[i]);
                        if (token !== false) {
                            return token;
                        } else if (this._backtrack) {
                            match = false;
                            continue; // rule action called reject() implying a rule MISmatch.
                        } else {
                            // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                            return false;
                        }
                    } else if (!this.options.flex) {
                        break;
                    }
                }
            }
            if (match) {
                token = this.test_match(match, rules[index]);
                if (token !== false) {
                    return token;
                }
                // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                return false;
            }
            if (this._input === "") {
                return this.EOF;
            } else {
                return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
            }
        },

        // return next match that has a token
        lex: function lex() {
            var r = this.next();
            if (r) {
                return r;
            } else {
                return this.lex();
            }
        },

        // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
        begin: function begin(condition) {
            this.conditionStack.push(condition);
        },

        // pop the previously active lexer condition state off the condition stack
        popState: function popState() {
            var n = this.conditionStack.length - 1;
            if (n > 0) {
                return this.conditionStack.pop();
            } else {
                return this.conditionStack[0];
            }
        },

        // produce the lexer rule set which is active for the currently active lexer condition state
        _currentRules: function _currentRules() {
            if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
                return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
            } else {
                return this.conditions["INITIAL"].rules;
            }
        },

        // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
        topState: function topState(n) {
            n = this.conditionStack.length - 1 - Math.abs(n || 0);
            if (n >= 0) {
                return this.conditionStack[n];
            } else {
                return "INITIAL";
            }
        },

        // alias for begin(condition)
        pushState: function pushState(condition) {
            this.begin(condition);
        },

        // return the number of states currently on the stack
        stateStackSize: function stateStackSize() {
            return this.conditionStack.length;
        },
        options: {},
        performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
            var YYSTATE = YY_START;
            switch ($avoiding_name_collisions) {
                case 0:
                    return 'STYLE';
                    break;
                case 1:
                    return 'LINKSTYLE';
                    break;
                case 2:
                    return 'CLASSDEF';
                    break;
                case 3:
                    return 'CLASS';
                    break;
                case 4:
                    return 'CLICK';
                    break;
                case 5:
                    return 12;
                    break;
                case 6:
                    return 13;
                    break;
                case 7:
                    return 47;
                    break;
                case 8:
                    return 35;
                    break;
                case 9:
                    return 36;
                    break;
                case 10:
                    return 'DIR';
                    break;
                case 11:
                    return 'DIR';
                    break;
                case 12:
                    return 'DIR';
                    break;
                case 13:
                    return 'DIR';
                    break;
                case 14:
                    return 'DIR';
                    break;
                case 15:
                    return 'DIR';
                    break;
                case 16:
                    return 17;
                    break;
                case 17:
                    return 23;
                    break;
                case 18:
                    return 18;
                    break;
                case 19:
                    return 28;
                    break;
                case 20:
                    return 40;
                    break;
                case 21:
                    return 32;
                    break;
                case 22:
                    return 21;
                    break;
                case 23:
                    return 22;
                    break;
                case 24:
                    return 'ARROW_CROSS';
                    break;
                case 25:
                    return 57;
                    break;
                case 26:
                    return 'ARROW_CIRCLE';
                    break;
                case 27:
                    return 58;
                    break;
                case 28:
                    return 25;
                    break;
                case 29:
                    return 19;
                    break;
                case 30:
                    return 20;
                    break;
                case 31:
                    return 16;
                    break;
                case 32:
                    return 'PIPE';
                    break;
                case 33:
                    return 'PS';
                    break;
                case 34:
                    return 'PE';
                    break;
                case 35:
                    return 37;
                    break;
                case 36:
                    return 39;
                    break;
                case 37:
                    return 8;
                    break;
                case 38:
                    return 10;
                    break;
                case 39:
                    return 'QUOTE';
                    break;
                case 40:
                    return 24;
                    break;
                case 41:
                    return 'NEWLINE';
                    break;
                case 42:
                    return 5;
                    break;
            }
        },
        rules: [/^(?:style\b)/, /^(?:linkStyle\b)/, /^(?:classDef\b)/, /^(?:class\b)/, /^(?:click\b)/, /^(?:graph\b)/, /^(?:digraph\b)/, /^(?:subgraph\b)/, /^(?:node\b)/, /^(?:edge\b)/, /^(?:LR\b)/, /^(?:RL\b)/, /^(?:TB\b)/, /^(?:BT\b)/, /^(?:TD\b)/, /^(?:BR\b)/, /^(?:[0-9])/, /^(?:#)/, /^(?::)/, /^(?:;)/, /^(?:,)/, /^(?:=)/, /^(?:\*)/, /^(?:\.)/, /^(?:--[x])/, /^(?:->)/, /^(?:--[o])/, /^(?:--)/, /^(?:-)/, /^(?:\+)/, /^(?:=)/, /^(?:[\u0021-\u0027\u002A-\u002E\u003F\u0041-\u005A\u0061-\u007A\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6]|[\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377]|[\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5]|[\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA]|[\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE]|[\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA]|[\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0]|[\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977]|[\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2]|[\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A]|[\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39]|[\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8]|[\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C]|[\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C]|[\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99]|[\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0]|[\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D]|[\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3]|[\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10]|[\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1]|[\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81]|[\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3]|[\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6]|[\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A]|[\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081]|[\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D]|[\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0]|[\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310]|[\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C]|[\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u1700-\u170C\u170E-\u1711]|[\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7]|[\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C]|[\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16]|[\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF]|[\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC]|[\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D]|[\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D]|[\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3]|[\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F]|[\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128]|[\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184]|[\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3]|[\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6]|[\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE]|[\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C]|[\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D]|[\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC]|[\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B]|[\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788]|[\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805]|[\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB]|[\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28]|[\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5]|[\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4]|[\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E]|[\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D]|[\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36]|[\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D]|[\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC]|[\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF]|[\uFFD2-\uFFD7\uFFDA-\uFFDC_])/, /^(?:\|)/, /^(?:\()/, /^(?:\))/, /^(?:\[)/, /^(?:\])/, /^(?:\{)/, /^(?:\})/, /^(?:")/, /^(?:\s)/, /^(?:\n)/, /^(?:$)/],
        conditions: { "INITIAL": { "rules": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42], "inclusive": true } }
    };
    return lexer;
}();
parser.lexer = lexer;
function Parser() {
    this.yy = {};
}
Parser.prototype = parser;parser.Parser = Parser;
return new Parser();

}();

if (true) {

exports.parser = parser;
exports.Parser = parser.Parser;
exports.parse = function () {
    return parser.parse.apply(parser, arguments);
};
exports.main = function commonjsMain(args) {
    if (!args[1]) {
        console.log('Usage: ' + args[0] + ' FILE');
        process.exit(1);
    }
    var source = __webpack_require__(8).readFileSync(__webpack_require__(9).normalize(args[1]), "utf8");
    return exports.parser.parse(source);
};
if (typeof module !== 'undefined' && __webpack_require__.c[__webpack_require__.s] === module) {
    exports.main(process.argv.slice(1));
}

} /* WEBPACK VAR INJECTION */}.call(exports, webpack_require(7), webpack_require(3)(module)))

/***/ }), /* 158 */ /***/ (function(module, exports, webpack_require) {

var _ = webpack_require(4),

PriorityQueue = __webpack_require__(159);

module.exports = dijkstra;

var DEFAULT_WEIGHT_FUNC = _.constant(1);

function dijkstra(g, source, weightFn, edgeFn) {

return runDijkstra(g, String(source),
                   weightFn || DEFAULT_WEIGHT_FUNC,
                   edgeFn || function(v) { return g.outEdges(v); });

}

function runDijkstra(g, source, weightFn, edgeFn) {

var results = {},
    pq = new PriorityQueue(),
    v, vEntry;

var updateNeighbors = function(edge) {
  var w = edge.v !== v ? edge.v : edge.w,
      wEntry = results[w],
      weight = weightFn(edge),
      distance = vEntry.distance + weight;

  if (weight < 0) {
    throw new Error("dijkstra does not allow negative edge weights. " +
                    "Bad edge: " + edge + " Weight: " + weight);
  }

  if (distance < wEntry.distance) {
    wEntry.distance = distance;
    wEntry.predecessor = v;
    pq.decrease(w, distance);
  }
};

g.nodes().forEach(function(v) {
  var distance = v === source ? 0 : Number.POSITIVE_INFINITY;
  results[v] = { distance: distance };
  pq.add(v, distance);
});

while (pq.size() > 0) {
  v = pq.removeMin();
  vEntry = results[v];
  if (vEntry.distance === Number.POSITIVE_INFINITY) {
    break;
  }

  edgeFn(v).forEach(updateNeighbors);
}

return results;

}

/***/ }), /* 159 */ /***/ (function(module, exports, webpack_require) {

var _ = webpack_require(4);

module.exports = PriorityQueue;

/**

* A min-priority queue data structure. This algorithm is derived from Cormen,
* et al., "Introduction to Algorithms". The basic idea of a min-priority
* queue is that you can efficiently (in O(1) time) get the smallest key in
* the queue. Adding and removing elements takes O(log n) time. A key can
* have its priority decreased in O(log n) time.
*/

function PriorityQueue() {

this._arr = [];
this._keyIndices = {};

}

/**

* Returns the number of elements in the queue. Takes `O(1)` time.
*/

PriorityQueue.prototype.size = function() {

return this._arr.length;

};

/**

* Returns the keys that are in the queue. Takes `O(n)` time.
*/

PriorityQueue.prototype.keys = function() {

return this._arr.map(function(x) { return x.key; });

};

/**

* Returns `true` if **key** is in the queue and `false` if not.
*/

PriorityQueue.prototype.has = function(key) {

return _.has(this._keyIndices, key);

};

/**

* Returns the priority for **key**. If **key** is not present in the queue
* then this function returns `undefined`. Takes `O(1)` time.
*
* @param {Object} key
*/

PriorityQueue.prototype.priority = function(key) {

var index = this._keyIndices[key];
if (index !== undefined) {
  return this._arr[index].priority;
}

};

/**

* Returns the key for the minimum element in this queue. If the queue is
* empty this function throws an Error. Takes `O(1)` time.
*/

PriorityQueue.prototype.min = function() {

if (this.size() === 0) {
  throw new Error("Queue underflow");
}
return this._arr[0].key;

};

/**

* Inserts a new key into the priority queue. If the key already exists in
* the queue this function returns `false`; otherwise it will return `true`.
* Takes `O(n)` time.
*
* @param {Object} key the key to add
* @param {Number} priority the initial priority for the key
*/

PriorityQueue.prototype.add = function(key, priority) {

var keyIndices = this._keyIndices;
key = String(key);
if (!_.has(keyIndices, key)) {
  var arr = this._arr;
  var index = arr.length;
  keyIndices[key] = index;
  arr.push({key: key, priority: priority});
  this._decrease(index);
  return true;
}
return false;

};

/**

* Removes and returns the smallest key in the queue. Takes `O(log n)` time.
*/

PriorityQueue.prototype.removeMin = function() {

this._swap(0, this._arr.length - 1);
var min = this._arr.pop();
delete this._keyIndices[min.key];
this._heapify(0);
return min.key;

};

/**

* Decreases the priority for **key** to **priority**. If the new priority is
* greater than the previous priority, this function will throw an Error.
*
* @param {Object} key the key for which to raise priority
* @param {Number} priority the new priority for the key
*/

PriorityQueue.prototype.decrease = function(key, priority) {

var index = this._keyIndices[key];
if (priority > this._arr[index].priority) {
  throw new Error("New priority is greater than current priority. " +
      "Key: " + key + " Old: " + this._arr[index].priority + " New: " + priority);
}
this._arr[index].priority = priority;
this._decrease(index);

};

PriorityQueue.prototype._heapify = function(i) {

var arr = this._arr;
var l = 2 * i,
    r = l + 1,
    largest = i;
if (l < arr.length) {
  largest = arr[l].priority < arr[largest].priority ? l : largest;
  if (r < arr.length) {
    largest = arr[r].priority < arr[largest].priority ? r : largest;
  }
  if (largest !== i) {
    this._swap(i, largest);
    this._heapify(largest);
  }
}

};

PriorityQueue.prototype._decrease = function(index) {

var arr = this._arr;
var priority = arr[index].priority;
var parent;
while (index !== 0) {
  parent = index >> 1;
  if (arr[parent].priority < priority) {
    break;
  }
  this._swap(index, parent);
  index = parent;
}

};

PriorityQueue.prototype._swap = function(i, j) {

var arr = this._arr;
var keyIndices = this._keyIndices;
var origArrI = arr[i];
var origArrJ = arr[j];
arr[i] = origArrJ;
arr[j] = origArrI;
keyIndices[origArrJ.key] = i;
keyIndices[origArrI.key] = j;

};

/***/ }), /* 160 */ /***/ (function(module, exports, webpack_require) {

var _ = webpack_require(4);

module.exports = tarjan;

function tarjan(g) {

var index = 0,
    stack = [],
    visited = {}, // node id -> { onStack, lowlink, index }
    results = [];

function dfs(v) {
  var entry = visited[v] = {
    onStack: true,
    lowlink: index,
    index: index++
  };
  stack.push(v);

  g.successors(v).forEach(function(w) {
    if (!_.has(visited, w)) {
      dfs(w);
      entry.lowlink = Math.min(entry.lowlink, visited[w].lowlink);
    } else if (visited[w].onStack) {
      entry.lowlink = Math.min(entry.lowlink, visited[w].index);
    }
  });

  if (entry.lowlink === entry.index) {
    var cmpt = [],
        w;
    do {
      w = stack.pop();
      visited[w].onStack = false;
      cmpt.push(w);
    } while (v !== w);
    results.push(cmpt);
  }
}

g.nodes().forEach(function(v) {
  if (!_.has(visited, v)) {
    dfs(v);
  }
});

return results;

}

/***/ }), /* 161 */ /***/ (function(module, exports, webpack_require) {

var _ = webpack_require(4);

module.exports = topsort; topsort.CycleException = CycleException;

function topsort(g) {

var visited = {},
    stack = {},
    results = [];

function visit(node) {
  if (_.has(stack, node)) {
    throw new CycleException();
  }

  if (!_.has(visited, node)) {
    stack[node] = true;
    visited[node] = true;
    _.each(g.predecessors(node), visit);
    delete stack[node];
    results.push(node);
  }
}

_.each(g.sinks(), visit);

if (_.size(visited) !== g.nodeCount()) {
  throw new CycleException();
}

return results;

}

function CycleException() {}

/***/ }), /* 162 */ /***/ (function(module, exports, webpack_require) {

var _ = webpack_require(4);

module.exports = dfs;

/*

* A helper that preforms a pre- or post-order traversal on the input graph
* and returns the nodes in the order they were visited. If the graph is
* undirected then this algorithm will navigate using neighbors. If the graph
* is directed then this algorithm will navigate using successors.
*
* Order must be one of "pre" or "post".
*/

function dfs(g, vs, order) {

if (!_.isArray(vs)) {
  vs = [vs];
}

var navigation = (g.isDirected() ? g.successors : g.neighbors).bind(g);

var acc = [],
    visited = {};
_.each(vs, function(v) {
  if (!g.hasNode(v)) {
    throw new Error("Graph does not have node: " + v);
  }

  doDfs(g, v, order === "post", visited, navigation, acc);
});
return acc;

}

function doDfs(g, v, postorder, visited, navigation, acc) {

if (!_.has(visited, v)) {
  visited[v] = true;

  if (!postorder) { acc.push(v); }
  _.each(navigation(v), function(w) {
    doDfs(g, w, postorder, visited, navigation, acc);
  });
  if (postorder) { acc.push(v); }
}

}

/***/ }), /* 163 */ /***/ (function(module, exports, webpack_require) {

“use strict”; /* WEBPACK VAR INJECTION */(function(process, module) {

/* parser generated by jison 0.4.17 */ /*

Returns a Parser object of the following structure:

Parser: {
  yy: {}
}

Parser.prototype: {
  yy: {},
  trace: function(),
  symbols_: {associative list: name ==> number},
  terminals_: {associative list: number ==> name},
  productions_: [...],
  performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
  table: [...],
  defaultActions: {...},
  parseError: function(str, hash),
  parse: function(input),

  lexer: {
      EOF: 1,
      parseError: function(str, hash),
      setInput: function(input),
      input: function(),
      unput: function(str),
      more: function(),
      less: function(n),
      pastInput: function(),
      upcomingInput: function(),
      showPosition: function(),
      test_match: function(regex_match_array, rule_index),
      next: function(),
      lex: function(),
      begin: function(condition),
      popState: function(),
      _currentRules: function(),
      topState: function(),
      pushState: function(condition),

      options: {
          ranges: boolean           (optional: true ==> token location info will include a .range[] member)
          flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
          backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
      },

      performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
      rules: [...],
      conditions: {associative list: name ==> set},
  }
}

token location info (@$, _$, etc.): {
  first_line: n,
  last_line: n,
  first_column: n,
  last_column: n,
  range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
}

the parseError function receives a 'hash' object with these members for lexer and parser errors: {
  text:        (matched text)
  token:       (the produced terminal token, if any)
  line:        (yylineno)
}
while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
  loc:         (yylloc)
  expected:    (string describing the set of expected tokens)
  recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
}

*/ var parser = function () {

var o = function o(k, v, _o, l) {
    for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v) {}return _o;
},
    $V0 = [1, 2],
    $V1 = [1, 3],
    $V2 = [1, 4],
    $V3 = [2, 4],
    $V4 = [1, 9],
    $V5 = [1, 11],
    $V6 = [1, 12],
    $V7 = [1, 14],
    $V8 = [1, 15],
    $V9 = [1, 17],
    $Va = [1, 18],
    $Vb = [1, 19],
    $Vc = [1, 20],
    $Vd = [1, 21],
    $Ve = [1, 23],
    $Vf = [1, 24],
    $Vg = [1, 4, 5, 10, 15, 16, 18, 20, 21, 22, 23, 24, 25, 27, 28, 39],
    $Vh = [1, 32],
    $Vi = [4, 5, 10, 15, 16, 18, 20, 21, 22, 23, 25, 28, 39],
    $Vj = [4, 5, 10, 15, 16, 18, 20, 21, 22, 23, 25, 27, 28, 39],
    $Vk = [37, 38, 39];
var parser = { trace: function trace() {},
    yy: {},
    symbols_: { "error": 2, "start": 3, "SPACE": 4, "NL": 5, "SD": 6, "document": 7, "line": 8, "statement": 9, "participant": 10, "actor": 11, "AS": 12, "restOfLine": 13, "signal": 14, "activate": 15, "deactivate": 16, "note_statement": 17, "title": 18, "text2": 19, "loop": 20, "end": 21, "opt": 22, "alt": 23, "else": 24, "par": 25, "par_sections": 26, "and": 27, "note": 28, "placement": 29, "over": 30, "actor_pair": 31, "spaceList": 32, ",": 33, "left_of": 34, "right_of": 35, "signaltype": 36, "+": 37, "-": 38, "ACTOR": 39, "SOLID_OPEN_ARROW": 40, "DOTTED_OPEN_ARROW": 41, "SOLID_ARROW": 42, "DOTTED_ARROW": 43, "SOLID_CROSS": 44, "DOTTED_CROSS": 45, "TXT": 46, "$accept": 0, "$end": 1 },
    terminals_: { 2: "error", 4: "SPACE", 5: "NL", 6: "SD", 10: "participant", 12: "AS", 13: "restOfLine", 15: "activate", 16: "deactivate", 18: "title", 20: "loop", 21: "end", 22: "opt", 23: "alt", 24: "else", 25: "par", 27: "and", 28: "note", 30: "over", 33: ",", 34: "left_of", 35: "right_of", 37: "+", 38: "-", 39: "ACTOR", 40: "SOLID_OPEN_ARROW", 41: "DOTTED_OPEN_ARROW", 42: "SOLID_ARROW", 43: "DOTTED_ARROW", 44: "SOLID_CROSS", 45: "DOTTED_CROSS", 46: "TXT" },
    productions_: [0, [3, 2], [3, 2], [3, 2], [7, 0], [7, 2], [8, 2], [8, 1], [8, 1], [9, 5], [9, 3], [9, 2], [9, 3], [9, 3], [9, 2], [9, 3], [9, 4], [9, 4], [9, 7], [9, 4], [26, 1], [26, 4], [17, 4], [17, 4], [32, 2], [32, 1], [31, 3], [31, 1], [29, 1], [29, 1], [14, 5], [14, 5], [14, 4], [11, 1], [36, 1], [36, 1], [36, 1], [36, 1], [36, 1], [36, 1], [19, 1]],
    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
        /* this == yyval */

        var $0 = $$.length - 1;
        switch (yystate) {
            case 3:
                yy.apply($$[$0]);return $$[$0];
                break;
            case 4:
                this.$ = [];
                break;
            case 5:
                $$[$0 - 1].push($$[$0]);this.$ = $$[$0 - 1];
                break;
            case 6:case 7:
                this.$ = $$[$0];
                break;
            case 8:
                this.$ = [];
                break;
            case 9:
                $$[$0 - 3].description = $$[$0 - 1];this.$ = $$[$0 - 3];
                break;
            case 10:
                this.$ = $$[$0 - 1];
                break;
            case 12:
                this.$ = { type: 'activeStart', signalType: yy.LINETYPE.ACTIVE_START, actor: $$[$0 - 1] };
                break;
            case 13:
                this.$ = { type: 'activeEnd', signalType: yy.LINETYPE.ACTIVE_END, actor: $$[$0 - 1] };
                break;
            case 15:
                this.$ = [{ type: 'setTitle', text: $$[$0 - 1] }];
                break;
            case 16:

                $$[$0 - 1].unshift({ type: 'loopStart', loopText: $$[$0 - 2], signalType: yy.LINETYPE.LOOP_START });
                $$[$0 - 1].push({ type: 'loopEnd', loopText: $$[$0 - 2], signalType: yy.LINETYPE.LOOP_END });
                this.$ = $$[$0 - 1];
                break;
            case 17:

                $$[$0 - 1].unshift({ type: 'optStart', optText: $$[$0 - 2], signalType: yy.LINETYPE.OPT_START });
                $$[$0 - 1].push({ type: 'optEnd', optText: $$[$0 - 2], signalType: yy.LINETYPE.OPT_END });
                this.$ = $$[$0 - 1];
                break;
            case 18:

                // Alt start
                $$[$0 - 4].unshift({ type: 'altStart', altText: $$[$0 - 5], signalType: yy.LINETYPE.ALT_START });
                // Content in alt is already in $$[$0-4]
                // Else
                $$[$0 - 4].push({ type: 'else', altText: $$[$0 - 2], signalType: yy.LINETYPE.ALT_ELSE });
                // Content in other alt
                $$[$0 - 4] = $$[$0 - 4].concat($$[$0 - 1]);
                // End
                $$[$0 - 4].push({ type: 'altEnd', signalType: yy.LINETYPE.ALT_END });

                this.$ = $$[$0 - 4];
                break;
            case 19:

                // Parallel start
                $$[$0 - 1].unshift({ type: 'parStart', parText: $$[$0 - 2], signalType: yy.LINETYPE.PAR_START });
                // Content in par is already in $$[$0-1]
                // End
                $$[$0 - 1].push({ type: 'parEnd', signalType: yy.LINETYPE.PAR_END });
                this.$ = $$[$0 - 1];
                break;
            case 21:
                this.$ = $$[$0 - 3].concat([{ type: 'and', parText: $$[$0 - 1], signalType: yy.LINETYPE.PAR_AND }, $$[$0]]);
                break;
            case 22:

                this.$ = [$$[$0 - 1], { type: 'addNote', placement: $$[$0 - 2], actor: $$[$0 - 1].actor, text: $$[$0] }];
                break;
            case 23:

                // Coerce actor_pair into a [to, from, ...] array
                $$[$0 - 2] = [].concat($$[$0 - 1], $$[$0 - 1]).slice(0, 2);
                $$[$0 - 2][0] = $$[$0 - 2][0].actor;
                $$[$0 - 2][1] = $$[$0 - 2][1].actor;
                this.$ = [$$[$0 - 1], { type: 'addNote', placement: yy.PLACEMENT.OVER, actor: $$[$0 - 2].slice(0, 2), text: $$[$0] }];
                break;
            case 26:
                this.$ = [$$[$0 - 2], $$[$0]];
                break;
            case 27:
                this.$ = $$[$0];
                break;
            case 28:
                this.$ = yy.PLACEMENT.LEFTOF;
                break;
            case 29:
                this.$ = yy.PLACEMENT.RIGHTOF;
                break;
            case 30:
                this.$ = [$$[$0 - 4], $$[$0 - 1], { type: 'addMessage', from: $$[$0 - 4].actor, to: $$[$0 - 1].actor, signalType: $$[$0 - 3], msg: $$[$0] }, { type: 'activeStart', signalType: yy.LINETYPE.ACTIVE_START, actor: $$[$0 - 1] }];
                break;
            case 31:
                this.$ = [$$[$0 - 4], $$[$0 - 1], { type: 'addMessage', from: $$[$0 - 4].actor, to: $$[$0 - 1].actor, signalType: $$[$0 - 3], msg: $$[$0] }, { type: 'activeEnd', signalType: yy.LINETYPE.ACTIVE_END, actor: $$[$0 - 4] }];
                break;
            case 32:
                this.$ = [$$[$0 - 3], $$[$0 - 1], { type: 'addMessage', from: $$[$0 - 3].actor, to: $$[$0 - 1].actor, signalType: $$[$0 - 2], msg: $$[$0] }];
                break;
            case 33:
                this.$ = { type: 'addActor', actor: $$[$0] };
                break;
            case 34:
                this.$ = yy.LINETYPE.SOLID_OPEN;
                break;
            case 35:
                this.$ = yy.LINETYPE.DOTTED_OPEN;
                break;
            case 36:
                this.$ = yy.LINETYPE.SOLID;
                break;
            case 37:
                this.$ = yy.LINETYPE.DOTTED;
                break;
            case 38:
                this.$ = yy.LINETYPE.SOLID_CROSS;
                break;
            case 39:
                this.$ = yy.LINETYPE.DOTTED_CROSS;
                break;
            case 40:
                this.$ = $$[$0].substring(1).trim().replace(/\\n/gm, "\n");
                break;
        }
    },
    table: [{ 3: 1, 4: $V0, 5: $V1, 6: $V2 }, { 1: [3] }, { 3: 5, 4: $V0, 5: $V1, 6: $V2 }, { 3: 6, 4: $V0, 5: $V1, 6: $V2 }, o([1, 4, 5, 10, 15, 16, 18, 20, 22, 23, 25, 28, 39], $V3, { 7: 7 }), { 1: [2, 1] }, { 1: [2, 2] }, { 1: [2, 3], 4: $V4, 5: $V5, 8: 8, 9: 10, 10: $V6, 11: 22, 14: 13, 15: $V7, 16: $V8, 17: 16, 18: $V9, 20: $Va, 22: $Vb, 23: $Vc, 25: $Vd, 28: $Ve, 39: $Vf }, o($Vg, [2, 5]), { 9: 25, 10: $V6, 11: 22, 14: 13, 15: $V7, 16: $V8, 17: 16, 18: $V9, 20: $Va, 22: $Vb, 23: $Vc, 25: $Vd, 28: $Ve, 39: $Vf }, o($Vg, [2, 7]), o($Vg, [2, 8]), { 11: 26, 39: $Vf }, { 5: [1, 27] }, { 11: 28, 39: $Vf }, { 11: 29, 39: $Vf }, { 5: [1, 30] }, { 19: 31, 46: $Vh }, { 13: [1, 33] }, { 13: [1, 34] }, { 13: [1, 35] }, { 13: [1, 36] }, { 36: 37, 40: [1, 38], 41: [1, 39], 42: [1, 40], 43: [1, 41], 44: [1, 42], 45: [1, 43] }, { 29: 44, 30: [1, 45], 34: [1, 46], 35: [1, 47] }, o([5, 12, 33, 40, 41, 42, 43, 44, 45, 46], [2, 33]), o($Vg, [2, 6]), { 5: [1, 49], 12: [1, 48] }, o($Vg, [2, 11]), { 5: [1, 50] }, { 5: [1, 51] }, o($Vg, [2, 14]), { 5: [1, 52] }, { 5: [2, 40] }, o($Vi, $V3, { 7: 53 }), o($Vi, $V3, { 7: 54 }), o([4, 5, 10, 15, 16, 18, 20, 22, 23, 24, 25, 28, 39], $V3, { 7: 55 }), o($Vj, $V3, { 26: 56, 7: 57 }), { 11: 60, 37: [1, 58], 38: [1, 59], 39: $Vf }, o($Vk, [2, 34]), o($Vk, [2, 35]), o($Vk, [2, 36]), o($Vk, [2, 37]), o($Vk, [2, 38]), o($Vk, [2, 39]), { 11: 61, 39: $Vf }, { 11: 63, 31: 62, 39: $Vf }, { 39: [2, 28] }, { 39: [2, 29] }, { 13: [1, 64] }, o($Vg, [2, 10]), o($Vg, [2, 12]), o($Vg, [2, 13]), o($Vg, [2, 15]), { 4: $V4, 5: $V5, 8: 8, 9: 10, 10: $V6, 11: 22, 14: 13, 15: $V7, 16: $V8, 17: 16, 18: $V9, 20: $Va, 21: [1, 65], 22: $Vb, 23: $Vc, 25: $Vd, 28: $Ve, 39: $Vf }, { 4: $V4, 5: $V5, 8: 8, 9: 10, 10: $V6, 11: 22, 14: 13, 15: $V7, 16: $V8, 17: 16, 18: $V9, 20: $Va, 21: [1, 66], 22: $Vb, 23: $Vc, 25: $Vd, 28: $Ve, 39: $Vf }, { 4: $V4, 5: $V5, 8: 8, 9: 10, 10: $V6, 11: 22, 14: 13, 15: $V7, 16: $V8, 17: 16, 18: $V9, 20: $Va, 22: $Vb, 23: $Vc, 24: [1, 67], 25: $Vd, 28: $Ve, 39: $Vf }, { 21: [1, 68] }, { 4: $V4, 5: $V5, 8: 8, 9: 10, 10: $V6, 11: 22, 14: 13, 15: $V7, 16: $V8, 17: 16, 18: $V9, 20: $Va, 21: [2, 20], 22: $Vb, 23: $Vc, 25: $Vd, 27: [1, 69], 28: $Ve, 39: $Vf }, { 11: 70, 39: $Vf }, { 11: 71, 39: $Vf }, { 19: 72, 46: $Vh }, { 19: 73, 46: $Vh }, { 19: 74, 46: $Vh }, { 33: [1, 75], 46: [2, 27] }, { 5: [1, 76] }, o($Vg, [2, 16]), o($Vg, [2, 17]), { 13: [1, 77] }, o($Vg, [2, 19]), { 13: [1, 78] }, { 19: 79, 46: $Vh }, { 19: 80, 46: $Vh }, { 5: [2, 32] }, { 5: [2, 22] }, { 5: [2, 23] }, { 11: 81, 39: $Vf }, o($Vg, [2, 9]), o($Vi, $V3, { 7: 82 }), o($Vj, $V3, { 7: 57, 26: 83 }), { 5: [2, 30] }, { 5: [2, 31] }, { 46: [2, 26] }, { 4: $V4, 5: $V5, 8: 8, 9: 10, 10: $V6, 11: 22, 14: 13, 15: $V7, 16: $V8, 17: 16, 18: $V9, 20: $Va, 21: [1, 84], 22: $Vb, 23: $Vc, 25: $Vd, 28: $Ve, 39: $Vf }, { 21: [2, 21] }, o($Vg, [2, 18])],
    defaultActions: { 5: [2, 1], 6: [2, 2], 32: [2, 40], 46: [2, 28], 47: [2, 29], 72: [2, 32], 73: [2, 22], 74: [2, 23], 79: [2, 30], 80: [2, 31], 81: [2, 26], 83: [2, 21] },
    parseError: function parseError(str, hash) {
        if (hash.recoverable) {
            this.trace(str);
        } else {
            var _parseError = function _parseError(msg, hash) {
                this.message = msg;
                this.hash = hash;
            };

            _parseError.prototype = Error;

            throw new _parseError(str, hash);
        }
    },
    parse: function parse(input) {
        var self = this,
            stack = [0],
            tstack = [],
            vstack = [null],
            lstack = [],
            table = this.table,
            yytext = '',
            yylineno = 0,
            yyleng = 0,
            recovering = 0,
            TERROR = 2,
            EOF = 1;
        var args = lstack.slice.call(arguments, 1);
        var lexer = Object.create(this.lexer);
        var sharedState = { yy: {} };
        for (var k in this.yy) {
            if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
                sharedState.yy[k] = this.yy[k];
            }
        }
        lexer.setInput(input, sharedState.yy);
        sharedState.yy.lexer = lexer;
        sharedState.yy.parser = this;
        if (typeof lexer.yylloc == 'undefined') {
            lexer.yylloc = {};
        }
        var yyloc = lexer.yylloc;
        lstack.push(yyloc);
        var ranges = lexer.options && lexer.options.ranges;
        if (typeof sharedState.yy.parseError === 'function') {
            this.parseError = sharedState.yy.parseError;
        } else {
            this.parseError = Object.getPrototypeOf(this).parseError;
        }
        function popStack(n) {
            stack.length = stack.length - 2 * n;
            vstack.length = vstack.length - n;
            lstack.length = lstack.length - n;
        }
        function lex() {
            var token;
            token = tstack.pop() || lexer.lex() || EOF;
            if (typeof token !== 'number') {
                if (token instanceof Array) {
                    tstack = token;
                    token = tstack.pop();
                }
                token = self.symbols_[token] || token;
            }
            return token;
        }
        var symbol,
            preErrorSymbol,
            state,
            action,
            a,
            r,
            yyval = {},
            p,
            len,
            newState,
            expected;
        while (true) {
            state = stack[stack.length - 1];
            if (this.defaultActions[state]) {
                action = this.defaultActions[state];
            } else {
                if (symbol === null || typeof symbol == 'undefined') {
                    symbol = lex();
                }
                action = table[state] && table[state][symbol];
            }
            if (typeof action === 'undefined' || !action.length || !action[0]) {
                var errStr = '';
                expected = [];
                for (p in table[state]) {
                    if (this.terminals_[p] && p > TERROR) {
                        expected.push('\'' + this.terminals_[p] + '\'');
                    }
                }
                if (lexer.showPosition) {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
                } else {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
                }
                this.parseError(errStr, {
                    text: lexer.match,
                    token: this.terminals_[symbol] || symbol,
                    line: lexer.yylineno,
                    loc: yyloc,
                    expected: expected
                });
            }
            if (action[0] instanceof Array && action.length > 1) {
                throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
            }
            switch (action[0]) {
                case 1:
                    stack.push(symbol);
                    vstack.push(lexer.yytext);
                    lstack.push(lexer.yylloc);
                    stack.push(action[1]);
                    symbol = null;
                    if (!preErrorSymbol) {
                        yyleng = lexer.yyleng;
                        yytext = lexer.yytext;
                        yylineno = lexer.yylineno;
                        yyloc = lexer.yylloc;
                        if (recovering > 0) {
                            recovering--;
                        }
                    } else {
                        symbol = preErrorSymbol;
                        preErrorSymbol = null;
                    }
                    break;
                case 2:
                    len = this.productions_[action[1]][1];
                    yyval.$ = vstack[vstack.length - len];
                    yyval._$ = {
                        first_line: lstack[lstack.length - (len || 1)].first_line,
                        last_line: lstack[lstack.length - 1].last_line,
                        first_column: lstack[lstack.length - (len || 1)].first_column,
                        last_column: lstack[lstack.length - 1].last_column
                    };
                    if (ranges) {
                        yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
                    }
                    r = this.performAction.apply(yyval, [yytext, yyleng, yylineno, sharedState.yy, action[1], vstack, lstack].concat(args));
                    if (typeof r !== 'undefined') {
                        return r;
                    }
                    if (len) {
                        stack = stack.slice(0, -1 * len * 2);
                        vstack = vstack.slice(0, -1 * len);
                        lstack = lstack.slice(0, -1 * len);
                    }
                    stack.push(this.productions_[action[1]][0]);
                    vstack.push(yyval.$);
                    lstack.push(yyval._$);
                    newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
                    stack.push(newState);
                    break;
                case 3:
                    return true;
            }
        }
        return true;
    } };

/* generated by jison-lex 0.3.4 */
var lexer = function () {
    var lexer = {

        EOF: 1,

        parseError: function parseError(str, hash) {
            if (this.yy.parser) {
                this.yy.parser.parseError(str, hash);
            } else {
                throw new Error(str);
            }
        },

        // resets the lexer, sets new input
        setInput: function setInput(input, yy) {
            this.yy = yy || this.yy || {};
            this._input = input;
            this._more = this._backtrack = this.done = false;
            this.yylineno = this.yyleng = 0;
            this.yytext = this.matched = this.match = '';
            this.conditionStack = ['INITIAL'];
            this.yylloc = {
                first_line: 1,
                first_column: 0,
                last_line: 1,
                last_column: 0
            };
            if (this.options.ranges) {
                this.yylloc.range = [0, 0];
            }
            this.offset = 0;
            return this;
        },

        // consumes and returns one char from the input
        input: function input() {
            var ch = this._input[0];
            this.yytext += ch;
            this.yyleng++;
            this.offset++;
            this.match += ch;
            this.matched += ch;
            var lines = ch.match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno++;
                this.yylloc.last_line++;
            } else {
                this.yylloc.last_column++;
            }
            if (this.options.ranges) {
                this.yylloc.range[1]++;
            }

            this._input = this._input.slice(1);
            return ch;
        },

        // unshifts one char (or a string) into the input
        unput: function unput(ch) {
            var len = ch.length;
            var lines = ch.split(/(?:\r\n?|\n)/g);

            this._input = ch + this._input;
            this.yytext = this.yytext.substr(0, this.yytext.length - len);
            //this.yyleng -= len;
            this.offset -= len;
            var oldLines = this.match.split(/(?:\r\n?|\n)/g);
            this.match = this.match.substr(0, this.match.length - 1);
            this.matched = this.matched.substr(0, this.matched.length - 1);

            if (lines.length - 1) {
                this.yylineno -= lines.length - 1;
            }
            var r = this.yylloc.range;

            this.yylloc = {
                first_line: this.yylloc.first_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.first_column,
                last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
            };

            if (this.options.ranges) {
                this.yylloc.range = [r[0], r[0] + this.yyleng - len];
            }
            this.yyleng = this.yytext.length;
            return this;
        },

        // When called from action, caches matched text and appends it on next action
        more: function more() {
            this._more = true;
            return this;
        },

        // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
        reject: function reject() {
            if (this.options.backtrack_lexer) {
                this._backtrack = true;
            } else {
                return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
            }
            return this;
        },

        // retain first n characters of the match
        less: function less(n) {
            this.unput(this.match.slice(n));
        },

        // displays already matched input, i.e. for error messages
        pastInput: function pastInput() {
            var past = this.matched.substr(0, this.matched.length - this.match.length);
            return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, "");
        },

        // displays upcoming input, i.e. for error messages
        upcomingInput: function upcomingInput() {
            var next = this.match;
            if (next.length < 20) {
                next += this._input.substr(0, 20 - next.length);
            }
            return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
        },

        // displays the character position where the lexing error occurred, i.e. for error messages
        showPosition: function showPosition() {
            var pre = this.pastInput();
            var c = new Array(pre.length + 1).join("-");
            return pre + this.upcomingInput() + "\n" + c + "^";
        },

        // test the lexed token: return FALSE when not a match, otherwise return token
        test_match: function test_match(match, indexed_rule) {
            var token, lines, backup;

            if (this.options.backtrack_lexer) {
                // save context
                backup = {
                    yylineno: this.yylineno,
                    yylloc: {
                        first_line: this.yylloc.first_line,
                        last_line: this.last_line,
                        first_column: this.yylloc.first_column,
                        last_column: this.yylloc.last_column
                    },
                    yytext: this.yytext,
                    match: this.match,
                    matches: this.matches,
                    matched: this.matched,
                    yyleng: this.yyleng,
                    offset: this.offset,
                    _more: this._more,
                    _input: this._input,
                    yy: this.yy,
                    conditionStack: this.conditionStack.slice(0),
                    done: this.done
                };
                if (this.options.ranges) {
                    backup.yylloc.range = this.yylloc.range.slice(0);
                }
            }

            lines = match[0].match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno += lines.length;
            }
            this.yylloc = {
                first_line: this.yylloc.last_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.last_column,
                last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
            };
            this.yytext += match[0];
            this.match += match[0];
            this.matches = match;
            this.yyleng = this.yytext.length;
            if (this.options.ranges) {
                this.yylloc.range = [this.offset, this.offset += this.yyleng];
            }
            this._more = false;
            this._backtrack = false;
            this._input = this._input.slice(match[0].length);
            this.matched += match[0];
            token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
            if (this.done && this._input) {
                this.done = false;
            }
            if (token) {
                return token;
            } else if (this._backtrack) {
                // recover context
                for (var k in backup) {
                    this[k] = backup[k];
                }
                return false; // rule action called reject() implying the next rule should be tested instead.
            }
            return false;
        },

        // return next match in input
        next: function next() {
            if (this.done) {
                return this.EOF;
            }
            if (!this._input) {
                this.done = true;
            }

            var token, match, tempMatch, index;
            if (!this._more) {
                this.yytext = '';
                this.match = '';
            }
            var rules = this._currentRules();
            for (var i = 0; i < rules.length; i++) {
                tempMatch = this._input.match(this.rules[rules[i]]);
                if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                    match = tempMatch;
                    index = i;
                    if (this.options.backtrack_lexer) {
                        token = this.test_match(tempMatch, rules[i]);
                        if (token !== false) {
                            return token;
                        } else if (this._backtrack) {
                            match = false;
                            continue; // rule action called reject() implying a rule MISmatch.
                        } else {
                            // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                            return false;
                        }
                    } else if (!this.options.flex) {
                        break;
                    }
                }
            }
            if (match) {
                token = this.test_match(match, rules[index]);
                if (token !== false) {
                    return token;
                }
                // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                return false;
            }
            if (this._input === "") {
                return this.EOF;
            } else {
                return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
            }
        },

        // return next match that has a token
        lex: function lex() {
            var r = this.next();
            if (r) {
                return r;
            } else {
                return this.lex();
            }
        },

        // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
        begin: function begin(condition) {
            this.conditionStack.push(condition);
        },

        // pop the previously active lexer condition state off the condition stack
        popState: function popState() {
            var n = this.conditionStack.length - 1;
            if (n > 0) {
                return this.conditionStack.pop();
            } else {
                return this.conditionStack[0];
            }
        },

        // produce the lexer rule set which is active for the currently active lexer condition state
        _currentRules: function _currentRules() {
            if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
                return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
            } else {
                return this.conditions["INITIAL"].rules;
            }
        },

        // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
        topState: function topState(n) {
            n = this.conditionStack.length - 1 - Math.abs(n || 0);
            if (n >= 0) {
                return this.conditionStack[n];
            } else {
                return "INITIAL";
            }
        },

        // alias for begin(condition)
        pushState: function pushState(condition) {
            this.begin(condition);
        },

        // return the number of states currently on the stack
        stateStackSize: function stateStackSize() {
            return this.conditionStack.length;
        },
        options: { "case-insensitive": true },
        performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
            var YYSTATE = YY_START;
            switch ($avoiding_name_collisions) {
                case 0:
                    return 5;
                    break;
                case 1:
                    /* skip all whitespace */
                    break;
                case 2:
                    /* skip same-line whitespace */
                    break;
                case 3:
                    /* skip comments */
                    break;
                case 4:
                    /* skip comments */
                    break;
                case 5:
                    this.begin('ID');return 10;
                    break;
                case 6:
                    this.begin('ALIAS');return 39;
                    break;
                case 7:
                    this.popState();this.popState();this.begin('LINE');return 12;
                    break;
                case 8:
                    this.popState();this.popState();return 5;
                    break;
                case 9:
                    this.begin('LINE');return 20;
                    break;
                case 10:
                    this.begin('LINE');return 22;
                    break;
                case 11:
                    this.begin('LINE');return 23;
                    break;
                case 12:
                    this.begin('LINE');return 24;
                    break;
                case 13:
                    this.begin('LINE');return 25;
                    break;
                case 14:
                    this.begin('LINE');return 27;
                    break;
                case 15:
                    this.popState();return 13;
                    break;
                case 16:
                    return 21;
                    break;
                case 17:
                    return 34;
                    break;
                case 18:
                    return 35;
                    break;
                case 19:
                    return 30;
                    break;
                case 20:
                    return 28;
                    break;
                case 21:
                    this.begin('ID');return 15;
                    break;
                case 22:
                    this.begin('ID');return 16;
                    break;
                case 23:
                    return 18;
                    break;
                case 24:
                    return 6;
                    break;
                case 25:
                    return 33;
                    break;
                case 26:
                    return 5;
                    break;
                case 27:
                    yy_.yytext = yy_.yytext.trim();return 39;
                    break;
                case 28:
                    return 42;
                    break;
                case 29:
                    return 43;
                    break;
                case 30:
                    return 40;
                    break;
                case 31:
                    return 41;
                    break;
                case 32:
                    return 44;
                    break;
                case 33:
                    return 45;
                    break;
                case 34:
                    return 46;
                    break;
                case 35:
                    return 37;
                    break;
                case 36:
                    return 38;
                    break;
                case 37:
                    return 5;
                    break;
                case 38:
                    return 'INVALID';
                    break;
            }
        },
        rules: [/^(?:[\n]+)/i, /^(?:\s+)/i, /^(?:((?!\n)\s)+)/i, /^(?:#[^\n]*)/i, /^(?:%[^\n]*)/i, /^(?:participant\b)/i, /^(?:[^\->:\n,;]+?(?=((?!\n)\s)+as(?!\n)\s|[#\n;]|$))/i, /^(?:as\b)/i, /^(?:(?:))/i, /^(?:loop\b)/i, /^(?:opt\b)/i, /^(?:alt\b)/i, /^(?:else\b)/i, /^(?:par\b)/i, /^(?:and\b)/i, /^(?:[^#\n;]*)/i, /^(?:end\b)/i, /^(?:left of\b)/i, /^(?:right of\b)/i, /^(?:over\b)/i, /^(?:note\b)/i, /^(?:activate\b)/i, /^(?:deactivate\b)/i, /^(?:title\b)/i, /^(?:sequenceDiagram\b)/i, /^(?:,)/i, /^(?:;)/i, /^(?:[^\+\->:\n,;]+)/i, /^(?:->>)/i, /^(?:-->>)/i, /^(?:->)/i, /^(?:-->)/i, /^(?:-[x])/i, /^(?:--[x])/i, /^(?::[^#\n;]+)/i, /^(?:\+)/i, /^(?:-)/i, /^(?:$)/i, /^(?:.)/i],
        conditions: { "LINE": { "rules": [2, 3, 15], "inclusive": false }, "ALIAS": { "rules": [2, 3, 7, 8], "inclusive": false }, "ID": { "rules": [2, 3, 6], "inclusive": false }, "INITIAL": { "rules": [0, 1, 3, 4, 5, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38], "inclusive": true } }
    };
    return lexer;
}();
parser.lexer = lexer;
function Parser() {
    this.yy = {};
}
Parser.prototype = parser;parser.Parser = Parser;
return new Parser();

}();

if (true) {

exports.parser = parser;
exports.Parser = parser.Parser;
exports.parse = function () {
    return parser.parse.apply(parser, arguments);
};
exports.main = function commonjsMain(args) {
    if (!args[1]) {
        console.log('Usage: ' + args[0] + ' FILE');
        process.exit(1);
    }
    var source = __webpack_require__(8).readFileSync(__webpack_require__(9).normalize(args[1]), "utf8");
    return exports.parser.parse(source);
};
if (typeof module !== 'undefined' && __webpack_require__.c[__webpack_require__.s] === module) {
    exports.main(process.argv.slice(1));
}

} /* WEBPACK VAR INJECTION */}.call(exports, webpack_require(7), webpack_require(3)(module)))

/***/ }), /* 164 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.apply = exports.setTitle = exports.addNote = exports.PLACEMENT = exports.ARROWTYPE = exports.LINETYPE = exports.clear = exports.getTitle = exports.getActorKeys = exports.getActor = exports.getActors = exports.getMessages = exports.addSignal = exports.addMessage = exports.addActor = undefined;

var _logger = webpack_require(1);

var actors = {}; var messages = []; var notes = []; var title = '';

var addActor = exports.addActor = function addActor(id, name, description) {

// Don't allow description nulling
var old = actors[id];
if (old && name === old.name && description == null) return;

// Don't allow null descriptions, either
if (description == null) description = name;

actors[id] = { name: name, description: description };

};

var addMessage = exports.addMessage = function addMessage(idFrom, idTo, message, answer) {

messages.push({ from: idFrom, to: idTo, message: message, answer: answer });

};

var addSignal = exports.addSignal = function addSignal(idFrom, idTo, message, messageType) {

_logger.logger.debug('Adding message from=' + idFrom + ' to=' + idTo + ' message=' + message + ' type=' + messageType);
messages.push({ from: idFrom, to: idTo, message: message, type: messageType });

};

var getMessages = exports.getMessages = function getMessages() {

return messages;

};

var getActors = exports.getActors = function getActors() {

return actors;

}; var getActor = exports.getActor = function getActor(id) {

return actors[id];

}; var getActorKeys = exports.getActorKeys = function getActorKeys() {

return Object.keys(actors);

}; var getTitle = exports.getTitle = function getTitle() {

return title;

};

var clear = exports.clear = function clear() {

actors = {};
messages = [];

};

var LINETYPE = exports.LINETYPE = {

SOLID: 0,
DOTTED: 1,
NOTE: 2,
SOLID_CROSS: 3,
DOTTED_CROSS: 4,
SOLID_OPEN: 5,
DOTTED_OPEN: 6,
LOOP_START: 10,
LOOP_END: 11,
ALT_START: 12,
ALT_ELSE: 13,
ALT_END: 14,
OPT_START: 15,
OPT_END: 16,
ACTIVE_START: 17,
ACTIVE_END: 18,
PAR_START: 19,
PAR_AND: 20,
PAR_END: 21

};

var ARROWTYPE = exports.ARROWTYPE = {

FILLED: 0,
OPEN: 1

};

var PLACEMENT = exports.PLACEMENT = {

LEFTOF: 0,
RIGHTOF: 1,
OVER: 2

};

var addNote = exports.addNote = function addNote(actor, placement, message) {

var note = { actor: actor, placement: placement, message: message

  // Coerce actor into a [to, from, ...] array
};var actors = [].concat(actor, actor);

notes.push(note);
messages.push({ from: actors[0], to: actors[1], message: message, type: LINETYPE.NOTE, placement: placement });

};

var setTitle = exports.setTitle = function setTitle(titleText) {

title = titleText;

};

var apply = exports.apply = function apply(param) {

if (param instanceof Array) {
  param.forEach(function (item) {
    apply(item);
  });
} else {
  switch (param.type) {
    case 'addActor':
      addActor(param.actor, param.actor, param.description);
      break;
    case 'activeStart':
      addSignal(param.actor, undefined, undefined, param.signalType);
      break;
    case 'activeEnd':
      addSignal(param.actor, undefined, undefined, param.signalType);
      break;
    case 'addNote':
      addNote(param.actor, param.placement, param.text);
      break;
    case 'addMessage':
      addSignal(param.from, param.to, param.msg, param.signalType);
      break;
    case 'loopStart':
      addSignal(undefined, undefined, param.loopText, param.signalType);
      break;
    case 'loopEnd':
      addSignal(undefined, undefined, undefined, param.signalType);
      break;
    case 'optStart':
      addSignal(undefined, undefined, param.optText, param.signalType);
      break;
    case 'optEnd':
      addSignal(undefined, undefined, undefined, param.signalType);
      break;
    case 'altStart':
      addSignal(undefined, undefined, param.altText, param.signalType);
      break;
    case 'else':
      addSignal(undefined, undefined, param.altText, param.signalType);
      break;
    case 'altEnd':
      addSignal(undefined, undefined, undefined, param.signalType);
      break;
    case 'setTitle':
      setTitle(param.text);
      break;
    case 'parStart':
      addSignal(undefined, undefined, param.parText, param.signalType);
      break;
    case 'and':
      addSignal(undefined, undefined, param.parText, param.signalType);
      break;
    case 'parEnd':
      addSignal(undefined, undefined, undefined, param.signalType);
      break;
  }
}

};

exports.default = {

addActor: addActor,
addMessage: addMessage,
addSignal: addSignal,
getMessages: getMessages,
getActors: getActors,
getActor: getActor,
getActorKeys: getActorKeys,
getTitle: getTitle,
clear: clear,
LINETYPE: LINETYPE,
ARROWTYPE: ARROWTYPE,
PLACEMENT: PLACEMENT,
addNote: addNote,
setTitle: setTitle,
apply: apply

};

/***/ }), /* 165 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.getInfo = exports.setInfo = exports.getMessage = exports.setMessage = undefined;

var _logger = webpack_require(1);

var message = ''; var info = false;

var setMessage = exports.setMessage = function setMessage(txt) {

_logger.logger.debug('Setting message to: ' + txt);
message = txt;

};

var getMessage = exports.getMessage = function getMessage() {

return message;

};

var setInfo = exports.setInfo = function setInfo(inf) {

info = inf;

};

var getInfo = exports.getInfo = function getInfo() {

return info;

};

exports.default = {

setMessage: setMessage,
getMessage: getMessage,
setInfo: setInfo,
getInfo: getInfo

};

/***/ }), /* 166 */ /***/ (function(module, exports, webpack_require) {

“use strict”; /* WEBPACK VAR INJECTION */(function(process, module) {

/* parser generated by jison 0.4.17 */ /*

Returns a Parser object of the following structure:

Parser: {
  yy: {}
}

Parser.prototype: {
  yy: {},
  trace: function(),
  symbols_: {associative list: name ==> number},
  terminals_: {associative list: number ==> name},
  productions_: [...],
  performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
  table: [...],
  defaultActions: {...},
  parseError: function(str, hash),
  parse: function(input),

  lexer: {
      EOF: 1,
      parseError: function(str, hash),
      setInput: function(input),
      input: function(),
      unput: function(str),
      more: function(),
      less: function(n),
      pastInput: function(),
      upcomingInput: function(),
      showPosition: function(),
      test_match: function(regex_match_array, rule_index),
      next: function(),
      lex: function(),
      begin: function(condition),
      popState: function(),
      _currentRules: function(),
      topState: function(),
      pushState: function(condition),

      options: {
          ranges: boolean           (optional: true ==> token location info will include a .range[] member)
          flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
          backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
      },

      performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
      rules: [...],
      conditions: {associative list: name ==> set},
  }
}

token location info (@$, _$, etc.): {
  first_line: n,
  last_line: n,
  first_column: n,
  last_column: n,
  range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
}

the parseError function receives a 'hash' object with these members for lexer and parser errors: {
  text:        (matched text)
  token:       (the produced terminal token, if any)
  line:        (yylineno)
}
while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
  loc:         (yylloc)
  expected:    (string describing the set of expected tokens)
  recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
}

*/ var parser = function () {

var o = function o(k, v, _o, l) {
    for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v) {}return _o;
},
    $V0 = [6, 9, 10, 12];
var parser = { trace: function trace() {},
    yy: {},
    symbols_: { "error": 2, "start": 3, "info": 4, "document": 5, "EOF": 6, "line": 7, "statement": 8, "NL": 9, "showInfo": 10, "message": 11, "say": 12, "TXT": 13, "$accept": 0, "$end": 1 },
    terminals_: { 2: "error", 4: "info", 6: "EOF", 9: "NL", 10: "showInfo", 12: "say", 13: "TXT" },
    productions_: [0, [3, 3], [5, 0], [5, 2], [7, 1], [7, 1], [8, 1], [8, 1], [11, 2]],
    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
        /* this == yyval */

        var $0 = $$.length - 1;
        switch (yystate) {
            case 1:
                return yy;
                break;
            case 4:

                break;
            case 6:
                yy.setInfo(true);
                break;
            case 7:
                yy.setMessage($$[$0]);
                break;
            case 8:
                this.$ = $$[$0 - 1].substring(1).trim().replace(/\\n/gm, "\n");
                break;
        }
    },
    table: [{ 3: 1, 4: [1, 2] }, { 1: [3] }, o($V0, [2, 2], { 5: 3 }), { 6: [1, 4], 7: 5, 8: 6, 9: [1, 7], 10: [1, 8], 11: 9, 12: [1, 10] }, { 1: [2, 1] }, o($V0, [2, 3]), o($V0, [2, 4]), o($V0, [2, 5]), o($V0, [2, 6]), o($V0, [2, 7]), { 13: [1, 11] }, o($V0, [2, 8])],
    defaultActions: { 4: [2, 1] },
    parseError: function parseError(str, hash) {
        if (hash.recoverable) {
            this.trace(str);
        } else {
            var _parseError = function _parseError(msg, hash) {
                this.message = msg;
                this.hash = hash;
            };

            _parseError.prototype = Error;

            throw new _parseError(str, hash);
        }
    },
    parse: function parse(input) {
        var self = this,
            stack = [0],
            tstack = [],
            vstack = [null],
            lstack = [],
            table = this.table,
            yytext = '',
            yylineno = 0,
            yyleng = 0,
            recovering = 0,
            TERROR = 2,
            EOF = 1;
        var args = lstack.slice.call(arguments, 1);
        var lexer = Object.create(this.lexer);
        var sharedState = { yy: {} };
        for (var k in this.yy) {
            if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
                sharedState.yy[k] = this.yy[k];
            }
        }
        lexer.setInput(input, sharedState.yy);
        sharedState.yy.lexer = lexer;
        sharedState.yy.parser = this;
        if (typeof lexer.yylloc == 'undefined') {
            lexer.yylloc = {};
        }
        var yyloc = lexer.yylloc;
        lstack.push(yyloc);
        var ranges = lexer.options && lexer.options.ranges;
        if (typeof sharedState.yy.parseError === 'function') {
            this.parseError = sharedState.yy.parseError;
        } else {
            this.parseError = Object.getPrototypeOf(this).parseError;
        }
        function popStack(n) {
            stack.length = stack.length - 2 * n;
            vstack.length = vstack.length - n;
            lstack.length = lstack.length - n;
        }
        function lex() {
            var token;
            token = tstack.pop() || lexer.lex() || EOF;
            if (typeof token !== 'number') {
                if (token instanceof Array) {
                    tstack = token;
                    token = tstack.pop();
                }
                token = self.symbols_[token] || token;
            }
            return token;
        }
        var symbol,
            preErrorSymbol,
            state,
            action,
            a,
            r,
            yyval = {},
            p,
            len,
            newState,
            expected;
        while (true) {
            state = stack[stack.length - 1];
            if (this.defaultActions[state]) {
                action = this.defaultActions[state];
            } else {
                if (symbol === null || typeof symbol == 'undefined') {
                    symbol = lex();
                }
                action = table[state] && table[state][symbol];
            }
            if (typeof action === 'undefined' || !action.length || !action[0]) {
                var errStr = '';
                expected = [];
                for (p in table[state]) {
                    if (this.terminals_[p] && p > TERROR) {
                        expected.push('\'' + this.terminals_[p] + '\'');
                    }
                }
                if (lexer.showPosition) {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
                } else {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
                }
                this.parseError(errStr, {
                    text: lexer.match,
                    token: this.terminals_[symbol] || symbol,
                    line: lexer.yylineno,
                    loc: yyloc,
                    expected: expected
                });
            }
            if (action[0] instanceof Array && action.length > 1) {
                throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
            }
            switch (action[0]) {
                case 1:
                    stack.push(symbol);
                    vstack.push(lexer.yytext);
                    lstack.push(lexer.yylloc);
                    stack.push(action[1]);
                    symbol = null;
                    if (!preErrorSymbol) {
                        yyleng = lexer.yyleng;
                        yytext = lexer.yytext;
                        yylineno = lexer.yylineno;
                        yyloc = lexer.yylloc;
                        if (recovering > 0) {
                            recovering--;
                        }
                    } else {
                        symbol = preErrorSymbol;
                        preErrorSymbol = null;
                    }
                    break;
                case 2:
                    len = this.productions_[action[1]][1];
                    yyval.$ = vstack[vstack.length - len];
                    yyval._$ = {
                        first_line: lstack[lstack.length - (len || 1)].first_line,
                        last_line: lstack[lstack.length - 1].last_line,
                        first_column: lstack[lstack.length - (len || 1)].first_column,
                        last_column: lstack[lstack.length - 1].last_column
                    };
                    if (ranges) {
                        yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
                    }
                    r = this.performAction.apply(yyval, [yytext, yyleng, yylineno, sharedState.yy, action[1], vstack, lstack].concat(args));
                    if (typeof r !== 'undefined') {
                        return r;
                    }
                    if (len) {
                        stack = stack.slice(0, -1 * len * 2);
                        vstack = vstack.slice(0, -1 * len);
                        lstack = lstack.slice(0, -1 * len);
                    }
                    stack.push(this.productions_[action[1]][0]);
                    vstack.push(yyval.$);
                    lstack.push(yyval._$);
                    newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
                    stack.push(newState);
                    break;
                case 3:
                    return true;
            }
        }
        return true;
    } };

/* generated by jison-lex 0.3.4 */
var lexer = function () {
    var lexer = {

        EOF: 1,

        parseError: function parseError(str, hash) {
            if (this.yy.parser) {
                this.yy.parser.parseError(str, hash);
            } else {
                throw new Error(str);
            }
        },

        // resets the lexer, sets new input
        setInput: function setInput(input, yy) {
            this.yy = yy || this.yy || {};
            this._input = input;
            this._more = this._backtrack = this.done = false;
            this.yylineno = this.yyleng = 0;
            this.yytext = this.matched = this.match = '';
            this.conditionStack = ['INITIAL'];
            this.yylloc = {
                first_line: 1,
                first_column: 0,
                last_line: 1,
                last_column: 0
            };
            if (this.options.ranges) {
                this.yylloc.range = [0, 0];
            }
            this.offset = 0;
            return this;
        },

        // consumes and returns one char from the input
        input: function input() {
            var ch = this._input[0];
            this.yytext += ch;
            this.yyleng++;
            this.offset++;
            this.match += ch;
            this.matched += ch;
            var lines = ch.match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno++;
                this.yylloc.last_line++;
            } else {
                this.yylloc.last_column++;
            }
            if (this.options.ranges) {
                this.yylloc.range[1]++;
            }

            this._input = this._input.slice(1);
            return ch;
        },

        // unshifts one char (or a string) into the input
        unput: function unput(ch) {
            var len = ch.length;
            var lines = ch.split(/(?:\r\n?|\n)/g);

            this._input = ch + this._input;
            this.yytext = this.yytext.substr(0, this.yytext.length - len);
            //this.yyleng -= len;
            this.offset -= len;
            var oldLines = this.match.split(/(?:\r\n?|\n)/g);
            this.match = this.match.substr(0, this.match.length - 1);
            this.matched = this.matched.substr(0, this.matched.length - 1);

            if (lines.length - 1) {
                this.yylineno -= lines.length - 1;
            }
            var r = this.yylloc.range;

            this.yylloc = {
                first_line: this.yylloc.first_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.first_column,
                last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
            };

            if (this.options.ranges) {
                this.yylloc.range = [r[0], r[0] + this.yyleng - len];
            }
            this.yyleng = this.yytext.length;
            return this;
        },

        // When called from action, caches matched text and appends it on next action
        more: function more() {
            this._more = true;
            return this;
        },

        // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
        reject: function reject() {
            if (this.options.backtrack_lexer) {
                this._backtrack = true;
            } else {
                return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
            }
            return this;
        },

        // retain first n characters of the match
        less: function less(n) {
            this.unput(this.match.slice(n));
        },

        // displays already matched input, i.e. for error messages
        pastInput: function pastInput() {
            var past = this.matched.substr(0, this.matched.length - this.match.length);
            return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, "");
        },

        // displays upcoming input, i.e. for error messages
        upcomingInput: function upcomingInput() {
            var next = this.match;
            if (next.length < 20) {
                next += this._input.substr(0, 20 - next.length);
            }
            return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
        },

        // displays the character position where the lexing error occurred, i.e. for error messages
        showPosition: function showPosition() {
            var pre = this.pastInput();
            var c = new Array(pre.length + 1).join("-");
            return pre + this.upcomingInput() + "\n" + c + "^";
        },

        // test the lexed token: return FALSE when not a match, otherwise return token
        test_match: function test_match(match, indexed_rule) {
            var token, lines, backup;

            if (this.options.backtrack_lexer) {
                // save context
                backup = {
                    yylineno: this.yylineno,
                    yylloc: {
                        first_line: this.yylloc.first_line,
                        last_line: this.last_line,
                        first_column: this.yylloc.first_column,
                        last_column: this.yylloc.last_column
                    },
                    yytext: this.yytext,
                    match: this.match,
                    matches: this.matches,
                    matched: this.matched,
                    yyleng: this.yyleng,
                    offset: this.offset,
                    _more: this._more,
                    _input: this._input,
                    yy: this.yy,
                    conditionStack: this.conditionStack.slice(0),
                    done: this.done
                };
                if (this.options.ranges) {
                    backup.yylloc.range = this.yylloc.range.slice(0);
                }
            }

            lines = match[0].match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno += lines.length;
            }
            this.yylloc = {
                first_line: this.yylloc.last_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.last_column,
                last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
            };
            this.yytext += match[0];
            this.match += match[0];
            this.matches = match;
            this.yyleng = this.yytext.length;
            if (this.options.ranges) {
                this.yylloc.range = [this.offset, this.offset += this.yyleng];
            }
            this._more = false;
            this._backtrack = false;
            this._input = this._input.slice(match[0].length);
            this.matched += match[0];
            token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
            if (this.done && this._input) {
                this.done = false;
            }
            if (token) {
                return token;
            } else if (this._backtrack) {
                // recover context
                for (var k in backup) {
                    this[k] = backup[k];
                }
                return false; // rule action called reject() implying the next rule should be tested instead.
            }
            return false;
        },

        // return next match in input
        next: function next() {
            if (this.done) {
                return this.EOF;
            }
            if (!this._input) {
                this.done = true;
            }

            var token, match, tempMatch, index;
            if (!this._more) {
                this.yytext = '';
                this.match = '';
            }
            var rules = this._currentRules();
            for (var i = 0; i < rules.length; i++) {
                tempMatch = this._input.match(this.rules[rules[i]]);
                if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                    match = tempMatch;
                    index = i;
                    if (this.options.backtrack_lexer) {
                        token = this.test_match(tempMatch, rules[i]);
                        if (token !== false) {
                            return token;
                        } else if (this._backtrack) {
                            match = false;
                            continue; // rule action called reject() implying a rule MISmatch.
                        } else {
                            // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                            return false;
                        }
                    } else if (!this.options.flex) {
                        break;
                    }
                }
            }
            if (match) {
                token = this.test_match(match, rules[index]);
                if (token !== false) {
                    return token;
                }
                // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                return false;
            }
            if (this._input === "") {
                return this.EOF;
            } else {
                return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
            }
        },

        // return next match that has a token
        lex: function lex() {
            var r = this.next();
            if (r) {
                return r;
            } else {
                return this.lex();
            }
        },

        // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
        begin: function begin(condition) {
            this.conditionStack.push(condition);
        },

        // pop the previously active lexer condition state off the condition stack
        popState: function popState() {
            var n = this.conditionStack.length - 1;
            if (n > 0) {
                return this.conditionStack.pop();
            } else {
                return this.conditionStack[0];
            }
        },

        // produce the lexer rule set which is active for the currently active lexer condition state
        _currentRules: function _currentRules() {
            if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
                return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
            } else {
                return this.conditions["INITIAL"].rules;
            }
        },

        // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
        topState: function topState(n) {
            n = this.conditionStack.length - 1 - Math.abs(n || 0);
            if (n >= 0) {
                return this.conditionStack[n];
            } else {
                return "INITIAL";
            }
        },

        // alias for begin(condition)
        pushState: function pushState(condition) {
            this.begin(condition);
        },

        // return the number of states currently on the stack
        stateStackSize: function stateStackSize() {
            return this.conditionStack.length;
        },
        options: { "case-insensitive": true },
        performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
            // Pre-lexer code can go here

            var YYSTATE = YY_START;
            switch ($avoiding_name_collisions) {
                case 0:
                    return 9;
                    break;
                case 1:
                    return 10;
                    break;
                case 2:
                    return 4;
                    break;
                case 3:
                    return 12;
                    break;
                case 4:
                    return 13;
                    break;
                case 5:
                    return 6;
                    break;
                case 6:
                    return 'INVALID';
                    break;
            }
        },
        rules: [/^(?:[\n]+)/i, /^(?:showInfo\b)/i, /^(?:info\b)/i, /^(?:say\b)/i, /^(?::[^#\n;]+)/i, /^(?:$)/i, /^(?:.)/i],
        conditions: { "INITIAL": { "rules": [0, 1, 2, 3, 4, 5, 6], "inclusive": true } }
    };
    return lexer;
}();
parser.lexer = lexer;
function Parser() {
    this.yy = {};
}
Parser.prototype = parser;parser.Parser = Parser;
return new Parser();

}();

if (true) {

exports.parser = parser;
exports.Parser = parser.Parser;
exports.parse = function () {
    return parser.parse.apply(parser, arguments);
};
exports.main = function commonjsMain(args) {
    if (!args[1]) {
        console.log('Usage: ' + args[0] + ' FILE');
        process.exit(1);
    }
    var source = __webpack_require__(8).readFileSync(__webpack_require__(9).normalize(args[1]), "utf8");
    return exports.parser.parse(source);
};
if (typeof module !== 'undefined' && __webpack_require__.c[__webpack_require__.s] === module) {
    exports.main(process.argv.slice(1));
}

} /* WEBPACK VAR INJECTION */}.call(exports, webpack_require(7), webpack_require(3)(module)))

/***/ }), /* 167 */ /***/ (function(module, exports, webpack_require) {

“use strict”; /* WEBPACK VAR INJECTION */(function(process, module) {

/* parser generated by jison 0.4.17 */ /*

Returns a Parser object of the following structure:

Parser: {
  yy: {}
}

Parser.prototype: {
  yy: {},
  trace: function(),
  symbols_: {associative list: name ==> number},
  terminals_: {associative list: number ==> name},
  productions_: [...],
  performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
  table: [...],
  defaultActions: {...},
  parseError: function(str, hash),
  parse: function(input),

  lexer: {
      EOF: 1,
      parseError: function(str, hash),
      setInput: function(input),
      input: function(),
      unput: function(str),
      more: function(),
      less: function(n),
      pastInput: function(),
      upcomingInput: function(),
      showPosition: function(),
      test_match: function(regex_match_array, rule_index),
      next: function(),
      lex: function(),
      begin: function(condition),
      popState: function(),
      _currentRules: function(),
      topState: function(),
      pushState: function(condition),

      options: {
          ranges: boolean           (optional: true ==> token location info will include a .range[] member)
          flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
          backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
      },

      performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
      rules: [...],
      conditions: {associative list: name ==> set},
  }
}

token location info (@$, _$, etc.): {
  first_line: n,
  last_line: n,
  first_column: n,
  last_column: n,
  range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
}

the parseError function receives a 'hash' object with these members for lexer and parser errors: {
  text:        (matched text)
  token:       (the produced terminal token, if any)
  line:        (yylineno)
}
while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
  loc:         (yylloc)
  expected:    (string describing the set of expected tokens)
  recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
}

*/ var parser = function () {

var o = function o(k, v, _o, l) {
    for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v) {}return _o;
},
    $V0 = [6, 8, 10, 11, 12, 13, 14],
    $V1 = [1, 9],
    $V2 = [1, 10],
    $V3 = [1, 11],
    $V4 = [1, 12];
var parser = { trace: function trace() {},
    yy: {},
    symbols_: { "error": 2, "start": 3, "gantt": 4, "document": 5, "EOF": 6, "line": 7, "SPACE": 8, "statement": 9, "NL": 10, "dateFormat": 11, "title": 12, "section": 13, "taskTxt": 14, "taskData": 15, "$accept": 0, "$end": 1 },
    terminals_: { 2: "error", 4: "gantt", 6: "EOF", 8: "SPACE", 10: "NL", 11: "dateFormat", 12: "title", 13: "section", 14: "taskTxt", 15: "taskData" },
    productions_: [0, [3, 3], [5, 0], [5, 2], [7, 2], [7, 1], [7, 1], [7, 1], [9, 1], [9, 1], [9, 1], [9, 2]],
    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
        /* this == yyval */

        var $0 = $$.length - 1;
        switch (yystate) {
            case 1:
                return $$[$0 - 1];
                break;
            case 2:
                this.$ = [];
                break;
            case 3:
                $$[$0 - 1].push($$[$0]);this.$ = $$[$0 - 1];
                break;
            case 4:case 5:
                this.$ = $$[$0];
                break;
            case 6:case 7:
                this.$ = [];
                break;
            case 8:
                yy.setDateFormat($$[$0].substr(11));this.$ = $$[$0].substr(11);
                break;
            case 9:
                yy.setTitle($$[$0].substr(6));this.$ = $$[$0].substr(6);
                break;
            case 10:
                yy.addSection($$[$0].substr(8));this.$ = $$[$0].substr(8);
                break;
            case 11:
                yy.addTask($$[$0 - 1], $$[$0]);this.$ = 'task';
                break;
        }
    },
    table: [{ 3: 1, 4: [1, 2] }, { 1: [3] }, o($V0, [2, 2], { 5: 3 }), { 6: [1, 4], 7: 5, 8: [1, 6], 9: 7, 10: [1, 8], 11: $V1, 12: $V2, 13: $V3, 14: $V4 }, o($V0, [2, 7], { 1: [2, 1] }), o($V0, [2, 3]), { 9: 13, 11: $V1, 12: $V2, 13: $V3, 14: $V4 }, o($V0, [2, 5]), o($V0, [2, 6]), o($V0, [2, 8]), o($V0, [2, 9]), o($V0, [2, 10]), { 15: [1, 14] }, o($V0, [2, 4]), o($V0, [2, 11])],
    defaultActions: {},
    parseError: function parseError(str, hash) {
        if (hash.recoverable) {
            this.trace(str);
        } else {
            var _parseError = function _parseError(msg, hash) {
                this.message = msg;
                this.hash = hash;
            };

            _parseError.prototype = Error;

            throw new _parseError(str, hash);
        }
    },
    parse: function parse(input) {
        var self = this,
            stack = [0],
            tstack = [],
            vstack = [null],
            lstack = [],
            table = this.table,
            yytext = '',
            yylineno = 0,
            yyleng = 0,
            recovering = 0,
            TERROR = 2,
            EOF = 1;
        var args = lstack.slice.call(arguments, 1);
        var lexer = Object.create(this.lexer);
        var sharedState = { yy: {} };
        for (var k in this.yy) {
            if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
                sharedState.yy[k] = this.yy[k];
            }
        }
        lexer.setInput(input, sharedState.yy);
        sharedState.yy.lexer = lexer;
        sharedState.yy.parser = this;
        if (typeof lexer.yylloc == 'undefined') {
            lexer.yylloc = {};
        }
        var yyloc = lexer.yylloc;
        lstack.push(yyloc);
        var ranges = lexer.options && lexer.options.ranges;
        if (typeof sharedState.yy.parseError === 'function') {
            this.parseError = sharedState.yy.parseError;
        } else {
            this.parseError = Object.getPrototypeOf(this).parseError;
        }
        function popStack(n) {
            stack.length = stack.length - 2 * n;
            vstack.length = vstack.length - n;
            lstack.length = lstack.length - n;
        }
        function lex() {
            var token;
            token = tstack.pop() || lexer.lex() || EOF;
            if (typeof token !== 'number') {
                if (token instanceof Array) {
                    tstack = token;
                    token = tstack.pop();
                }
                token = self.symbols_[token] || token;
            }
            return token;
        }
        var symbol,
            preErrorSymbol,
            state,
            action,
            a,
            r,
            yyval = {},
            p,
            len,
            newState,
            expected;
        while (true) {
            state = stack[stack.length - 1];
            if (this.defaultActions[state]) {
                action = this.defaultActions[state];
            } else {
                if (symbol === null || typeof symbol == 'undefined') {
                    symbol = lex();
                }
                action = table[state] && table[state][symbol];
            }
            if (typeof action === 'undefined' || !action.length || !action[0]) {
                var errStr = '';
                expected = [];
                for (p in table[state]) {
                    if (this.terminals_[p] && p > TERROR) {
                        expected.push('\'' + this.terminals_[p] + '\'');
                    }
                }
                if (lexer.showPosition) {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
                } else {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
                }
                this.parseError(errStr, {
                    text: lexer.match,
                    token: this.terminals_[symbol] || symbol,
                    line: lexer.yylineno,
                    loc: yyloc,
                    expected: expected
                });
            }
            if (action[0] instanceof Array && action.length > 1) {
                throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
            }
            switch (action[0]) {
                case 1:
                    stack.push(symbol);
                    vstack.push(lexer.yytext);
                    lstack.push(lexer.yylloc);
                    stack.push(action[1]);
                    symbol = null;
                    if (!preErrorSymbol) {
                        yyleng = lexer.yyleng;
                        yytext = lexer.yytext;
                        yylineno = lexer.yylineno;
                        yyloc = lexer.yylloc;
                        if (recovering > 0) {
                            recovering--;
                        }
                    } else {
                        symbol = preErrorSymbol;
                        preErrorSymbol = null;
                    }
                    break;
                case 2:
                    len = this.productions_[action[1]][1];
                    yyval.$ = vstack[vstack.length - len];
                    yyval._$ = {
                        first_line: lstack[lstack.length - (len || 1)].first_line,
                        last_line: lstack[lstack.length - 1].last_line,
                        first_column: lstack[lstack.length - (len || 1)].first_column,
                        last_column: lstack[lstack.length - 1].last_column
                    };
                    if (ranges) {
                        yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
                    }
                    r = this.performAction.apply(yyval, [yytext, yyleng, yylineno, sharedState.yy, action[1], vstack, lstack].concat(args));
                    if (typeof r !== 'undefined') {
                        return r;
                    }
                    if (len) {
                        stack = stack.slice(0, -1 * len * 2);
                        vstack = vstack.slice(0, -1 * len);
                        lstack = lstack.slice(0, -1 * len);
                    }
                    stack.push(this.productions_[action[1]][0]);
                    vstack.push(yyval.$);
                    lstack.push(yyval._$);
                    newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
                    stack.push(newState);
                    break;
                case 3:
                    return true;
            }
        }
        return true;
    } };

/* generated by jison-lex 0.3.4 */
var lexer = function () {
    var lexer = {

        EOF: 1,

        parseError: function parseError(str, hash) {
            if (this.yy.parser) {
                this.yy.parser.parseError(str, hash);
            } else {
                throw new Error(str);
            }
        },

        // resets the lexer, sets new input
        setInput: function setInput(input, yy) {
            this.yy = yy || this.yy || {};
            this._input = input;
            this._more = this._backtrack = this.done = false;
            this.yylineno = this.yyleng = 0;
            this.yytext = this.matched = this.match = '';
            this.conditionStack = ['INITIAL'];
            this.yylloc = {
                first_line: 1,
                first_column: 0,
                last_line: 1,
                last_column: 0
            };
            if (this.options.ranges) {
                this.yylloc.range = [0, 0];
            }
            this.offset = 0;
            return this;
        },

        // consumes and returns one char from the input
        input: function input() {
            var ch = this._input[0];
            this.yytext += ch;
            this.yyleng++;
            this.offset++;
            this.match += ch;
            this.matched += ch;
            var lines = ch.match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno++;
                this.yylloc.last_line++;
            } else {
                this.yylloc.last_column++;
            }
            if (this.options.ranges) {
                this.yylloc.range[1]++;
            }

            this._input = this._input.slice(1);
            return ch;
        },

        // unshifts one char (or a string) into the input
        unput: function unput(ch) {
            var len = ch.length;
            var lines = ch.split(/(?:\r\n?|\n)/g);

            this._input = ch + this._input;
            this.yytext = this.yytext.substr(0, this.yytext.length - len);
            //this.yyleng -= len;
            this.offset -= len;
            var oldLines = this.match.split(/(?:\r\n?|\n)/g);
            this.match = this.match.substr(0, this.match.length - 1);
            this.matched = this.matched.substr(0, this.matched.length - 1);

            if (lines.length - 1) {
                this.yylineno -= lines.length - 1;
            }
            var r = this.yylloc.range;

            this.yylloc = {
                first_line: this.yylloc.first_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.first_column,
                last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
            };

            if (this.options.ranges) {
                this.yylloc.range = [r[0], r[0] + this.yyleng - len];
            }
            this.yyleng = this.yytext.length;
            return this;
        },

        // When called from action, caches matched text and appends it on next action
        more: function more() {
            this._more = true;
            return this;
        },

        // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
        reject: function reject() {
            if (this.options.backtrack_lexer) {
                this._backtrack = true;
            } else {
                return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
            }
            return this;
        },

        // retain first n characters of the match
        less: function less(n) {
            this.unput(this.match.slice(n));
        },

        // displays already matched input, i.e. for error messages
        pastInput: function pastInput() {
            var past = this.matched.substr(0, this.matched.length - this.match.length);
            return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, "");
        },

        // displays upcoming input, i.e. for error messages
        upcomingInput: function upcomingInput() {
            var next = this.match;
            if (next.length < 20) {
                next += this._input.substr(0, 20 - next.length);
            }
            return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
        },

        // displays the character position where the lexing error occurred, i.e. for error messages
        showPosition: function showPosition() {
            var pre = this.pastInput();
            var c = new Array(pre.length + 1).join("-");
            return pre + this.upcomingInput() + "\n" + c + "^";
        },

        // test the lexed token: return FALSE when not a match, otherwise return token
        test_match: function test_match(match, indexed_rule) {
            var token, lines, backup;

            if (this.options.backtrack_lexer) {
                // save context
                backup = {
                    yylineno: this.yylineno,
                    yylloc: {
                        first_line: this.yylloc.first_line,
                        last_line: this.last_line,
                        first_column: this.yylloc.first_column,
                        last_column: this.yylloc.last_column
                    },
                    yytext: this.yytext,
                    match: this.match,
                    matches: this.matches,
                    matched: this.matched,
                    yyleng: this.yyleng,
                    offset: this.offset,
                    _more: this._more,
                    _input: this._input,
                    yy: this.yy,
                    conditionStack: this.conditionStack.slice(0),
                    done: this.done
                };
                if (this.options.ranges) {
                    backup.yylloc.range = this.yylloc.range.slice(0);
                }
            }

            lines = match[0].match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno += lines.length;
            }
            this.yylloc = {
                first_line: this.yylloc.last_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.last_column,
                last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
            };
            this.yytext += match[0];
            this.match += match[0];
            this.matches = match;
            this.yyleng = this.yytext.length;
            if (this.options.ranges) {
                this.yylloc.range = [this.offset, this.offset += this.yyleng];
            }
            this._more = false;
            this._backtrack = false;
            this._input = this._input.slice(match[0].length);
            this.matched += match[0];
            token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
            if (this.done && this._input) {
                this.done = false;
            }
            if (token) {
                return token;
            } else if (this._backtrack) {
                // recover context
                for (var k in backup) {
                    this[k] = backup[k];
                }
                return false; // rule action called reject() implying the next rule should be tested instead.
            }
            return false;
        },

        // return next match in input
        next: function next() {
            if (this.done) {
                return this.EOF;
            }
            if (!this._input) {
                this.done = true;
            }

            var token, match, tempMatch, index;
            if (!this._more) {
                this.yytext = '';
                this.match = '';
            }
            var rules = this._currentRules();
            for (var i = 0; i < rules.length; i++) {
                tempMatch = this._input.match(this.rules[rules[i]]);
                if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                    match = tempMatch;
                    index = i;
                    if (this.options.backtrack_lexer) {
                        token = this.test_match(tempMatch, rules[i]);
                        if (token !== false) {
                            return token;
                        } else if (this._backtrack) {
                            match = false;
                            continue; // rule action called reject() implying a rule MISmatch.
                        } else {
                            // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                            return false;
                        }
                    } else if (!this.options.flex) {
                        break;
                    }
                }
            }
            if (match) {
                token = this.test_match(match, rules[index]);
                if (token !== false) {
                    return token;
                }
                // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                return false;
            }
            if (this._input === "") {
                return this.EOF;
            } else {
                return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
            }
        },

        // return next match that has a token
        lex: function lex() {
            var r = this.next();
            if (r) {
                return r;
            } else {
                return this.lex();
            }
        },

        // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
        begin: function begin(condition) {
            this.conditionStack.push(condition);
        },

        // pop the previously active lexer condition state off the condition stack
        popState: function popState() {
            var n = this.conditionStack.length - 1;
            if (n > 0) {
                return this.conditionStack.pop();
            } else {
                return this.conditionStack[0];
            }
        },

        // produce the lexer rule set which is active for the currently active lexer condition state
        _currentRules: function _currentRules() {
            if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
                return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
            } else {
                return this.conditions["INITIAL"].rules;
            }
        },

        // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
        topState: function topState(n) {
            n = this.conditionStack.length - 1 - Math.abs(n || 0);
            if (n >= 0) {
                return this.conditionStack[n];
            } else {
                return "INITIAL";
            }
        },

        // alias for begin(condition)
        pushState: function pushState(condition) {
            this.begin(condition);
        },

        // return the number of states currently on the stack
        stateStackSize: function stateStackSize() {
            return this.conditionStack.length;
        },
        options: { "case-insensitive": true },
        performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
            // Pre-lexer code can go here

            var YYSTATE = YY_START;
            switch ($avoiding_name_collisions) {
                case 0:
                    return 10;
                    break;
                case 1:
                    /* skip whitespace */
                    break;
                case 2:
                    /* skip comments */
                    break;
                case 3:
                    /* skip comments */
                    break;
                case 4:
                    return 4;
                    break;
                case 5:
                    return 11;
                    break;
                case 6:
                    return 'date';
                    break;
                case 7:
                    return 12;
                    break;
                case 8:
                    return 13;
                    break;
                case 9:
                    return 14;
                    break;
                case 10:
                    return 15;
                    break;
                case 11:
                    return ':';
                    break;
                case 12:
                    return 6;
                    break;
                case 13:
                    return 'INVALID';
                    break;
            }
        },
        rules: [/^(?:[\n]+)/i, /^(?:\s+)/i, /^(?:#[^\n]*)/i, /^(?:%[^\n]*)/i, /^(?:gantt\b)/i, /^(?:dateFormat\s[^#\n;]+)/i, /^(?:\d\d\d\d-\d\d-\d\d\b)/i, /^(?:title\s[^#\n;]+)/i, /^(?:section\s[^#:\n;]+)/i, /^(?:[^#:\n;]+)/i, /^(?::[^#\n;]+)/i, /^(?::)/i, /^(?:$)/i, /^(?:.)/i],
        conditions: { "INITIAL": { "rules": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], "inclusive": true } }
    };
    return lexer;
}();
parser.lexer = lexer;
function Parser() {
    this.yy = {};
}
Parser.prototype = parser;parser.Parser = Parser;
return new Parser();

}();

if (true) {

exports.parser = parser;
exports.Parser = parser.Parser;
exports.parse = function () {
    return parser.parse.apply(parser, arguments);
};
exports.main = function commonjsMain(args) {
    if (!args[1]) {
        console.log('Usage: ' + args[0] + ' FILE');
        process.exit(1);
    }
    var source = __webpack_require__(8).readFileSync(__webpack_require__(9).normalize(args[1]), "utf8");
    return exports.parser.parse(source);
};
if (typeof module !== 'undefined' && __webpack_require__.c[__webpack_require__.s] === module) {
    exports.main(process.argv.slice(1));
}

} /* WEBPACK VAR INJECTION */}.call(exports, webpack_require(7), webpack_require(3)(module)))

/***/ }), /* 168 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.addTaskOrg = exports.findTaskById = exports.addTask = exports.getTasks = exports.addSection = exports.getTitle = exports.setTitle = exports.getDateFormat = exports.setDateFormat = exports.clear = undefined;

var _moment = webpack_require(0);

var _moment2 = _interopRequireDefault(_moment);

var _logger = webpack_require(1);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var dateFormat = ''; var title = ''; var sections = []; var tasks = []; var currentSection = '';

var clear = exports.clear = function clear() {

sections = [];
tasks = [];
currentSection = '';
title = '';
taskCnt = 0;
lastTask = undefined;
lastTaskID = undefined;
rawTasks = [];

};

var setDateFormat = exports.setDateFormat = function setDateFormat(txt) {

dateFormat = txt;

};

var getDateFormat = exports.getDateFormat = function getDateFormat() {

return dateFormat;

}; var setTitle = exports.setTitle = function setTitle(txt) {

title = txt;

};

var getTitle = exports.getTitle = function getTitle() {

return title;

};

var addSection = exports.addSection = function addSection(txt) {

currentSection = txt;
sections.push(txt);

};

var getTasks = exports.getTasks = function getTasks() {

var allItemsPricessed = compileTasks();
var maxDepth = 10;
var iterationCount = 0;
while (!allItemsPricessed && iterationCount < maxDepth) {
  allItemsPricessed = compileTasks();
  iterationCount++;
}

tasks = rawTasks;

return tasks;

};

var getStartDate = function getStartDate(prevTime, dateFormat, str) {

str = str.trim();

// Test for after
var re = /^after\s+([\d\w-]+)/;
var afterStatement = re.exec(str.trim());

if (afterStatement !== null) {
  var task = findTaskById(afterStatement[1]);

  if (typeof task === 'undefined') {
    var dt = new Date();
    dt.setHours(0, 0, 0, 0);
    return dt;
  }
  return task.endTime;
}

// Check for actual date set
if ((0, _moment2.default)(str, dateFormat.trim(), true).isValid()) {
  return (0, _moment2.default)(str, dateFormat.trim(), true).toDate();
} else {
  _logger.logger.debug('Invalid date:' + str);
  _logger.logger.debug('With date format:' + dateFormat.trim());
}

// Default date - now
return new Date();

};

var getEndDate = function getEndDate(prevTime, dateFormat, str) {

str = str.trim();

// Check for actual date
if ((0, _moment2.default)(str, dateFormat.trim(), true).isValid()) {
  return (0, _moment2.default)(str, dateFormat.trim()).toDate();
}

var d = (0, _moment2.default)(prevTime);
// Check for length
var re = /^([\d]+)([wdhms])/;
var durationStatement = re.exec(str.trim());

if (durationStatement !== null) {
  switch (durationStatement[2]) {
    case 's':
      d.add(durationStatement[1], 'seconds');
      break;
    case 'm':
      d.add(durationStatement[1], 'minutes');
      break;
    case 'h':
      d.add(durationStatement[1], 'hours');
      break;
    case 'd':
      d.add(durationStatement[1], 'days');
      break;
    case 'w':
      d.add(durationStatement[1], 'weeks');
      break;
  }
  return d.toDate();
}
// Default date - now
return d.toDate();

};

var taskCnt = 0; var parseId = function parseId(idStr) {

if (typeof idStr === 'undefined') {
  taskCnt = taskCnt + 1;
  return 'task' + taskCnt;
}
return idStr;

}; // id, startDate, endDate // id, startDate, length // id, after x, endDate // id, after x, length // startDate, endDate // startDate, length // after x, endDate // after x, length // endDate // length

var compileData = function compileData(prevTask, dataStr) {

var ds;

if (dataStr.substr(0, 1) === ':') {
  ds = dataStr.substr(1, dataStr.length);
} else {
  ds = dataStr;
}

var data = ds.split(',');

var task = {};
var df = getDateFormat();

// Get tags like active, done cand crit
var matchFound = true;
while (matchFound) {
  matchFound = false;
  if (data[0].match(/^\s*active\s*$/)) {
    task.active = true;
    data.shift(1);
    matchFound = true;
  }
  if (data[0].match(/^\s*done\s*$/)) {
    task.done = true;
    data.shift(1);
    matchFound = true;
  }
  if (data[0].match(/^\s*crit\s*$/)) {
    task.crit = true;
    data.shift(1);
    matchFound = true;
  }
}
var i;
for (i = 0; i < data.length; i++) {
  data[i] = data[i].trim();
}

switch (data.length) {
  case 1:
    task.id = parseId();
    task.startTime = prevTask.endTime;
    task.endTime = getEndDate(task.startTime, df, data[0]);
    break;
  case 2:
    task.id = parseId();
    task.startTime = getStartDate(undefined, df, data[0]);
    task.endTime = getEndDate(task.startTime, df, data[1]);
    break;
  case 3:
    task.id = parseId(data[0]);
    task.startTime = getStartDate(undefined, df, data[1]);
    task.endTime = getEndDate(task.startTime, df, data[2]);
    break;
  default:
}

return task;

};

var parseData = function parseData(prevTaskId, dataStr) {

var ds;

if (dataStr.substr(0, 1) === ':') {
  ds = dataStr.substr(1, dataStr.length);
} else {
  ds = dataStr;
}

var data = ds.split(',');

var task = {};

// Get tags like active, done cand crit
var matchFound = true;
while (matchFound) {
  matchFound = false;
  if (data[0].match(/^\s*active\s*$/)) {
    task.active = true;
    data.shift(1);
    matchFound = true;
  }
  if (data[0].match(/^\s*done\s*$/)) {
    task.done = true;
    data.shift(1);
    matchFound = true;
  }
  if (data[0].match(/^\s*crit\s*$/)) {
    task.crit = true;
    data.shift(1);
    matchFound = true;
  }
}
var i;
for (i = 0; i < data.length; i++) {
  data[i] = data[i].trim();
}

switch (data.length) {
  case 1:
    task.id = parseId();
    task.startTime = { type: 'prevTaskEnd', id: prevTaskId };
    task.endTime = { data: data[0] };
    break;
  case 2:
    task.id = parseId();
    task.startTime = { type: 'getStartDate', startData: data[0] };
    task.endTime = { data: data[1] };
    break;
  case 3:
    task.id = parseId(data[0]);
    task.startTime = { type: 'getStartDate', startData: data[1] };
    task.endTime = { data: data[2] };
    break;
  default:
}

return task;

};

var lastTask; var lastTaskID; var rawTasks = []; var taskDb = {}; var addTask = exports.addTask = function addTask(descr, data) {

var rawTask = {
  section: currentSection,
  type: currentSection,
  processed: false,
  raw: { data: data },
  task: descr
};
var taskInfo = parseData(lastTaskID, data);
rawTask.raw.startTime = taskInfo.startTime;
rawTask.raw.endTime = taskInfo.endTime;
rawTask.id = taskInfo.id;
rawTask.prevTaskId = lastTaskID;
rawTask.active = taskInfo.active;
rawTask.done = taskInfo.done;
rawTask.crit = taskInfo.crit;

var pos = rawTasks.push(rawTask);

lastTaskID = rawTask.id;
// Store cross ref
taskDb[rawTask.id] = pos - 1;

};

var findTaskById = exports.findTaskById = function findTaskById(id) {

var pos = taskDb[id];
return rawTasks[pos];

};

var addTaskOrg = exports.addTaskOrg = function addTaskOrg(descr, data) {

var newTask = {
  section: currentSection,
  type: currentSection,
  description: descr,
  task: descr
};
var taskInfo = compileData(lastTask, data);
newTask.startTime = taskInfo.startTime;
newTask.endTime = taskInfo.endTime;
newTask.id = taskInfo.id;
newTask.active = taskInfo.active;
newTask.done = taskInfo.done;
newTask.crit = taskInfo.crit;
lastTask = newTask;
tasks.push(newTask);

};

var compileTasks = function compileTasks() {

var df = getDateFormat();

var compileTask = function compileTask(pos) {
  var task = rawTasks[pos];
  var startTime = '';
  switch (rawTasks[pos].raw.startTime.type) {
    case 'prevTaskEnd':
      var prevTask = findTaskById(task.prevTaskId);
      task.startTime = prevTask.endTime;
      break;
    case 'getStartDate':
      startTime = getStartDate(undefined, df, rawTasks[pos].raw.startTime.startData);
      if (startTime) {
        rawTasks[pos].startTime = startTime;
      }
      break;
  }

  if (rawTasks[pos].startTime) {
    rawTasks[pos].endTime = getEndDate(rawTasks[pos].startTime, df, rawTasks[pos].raw.endTime.data);
    if (rawTasks[pos].endTime) {
      rawTasks[pos].processed = true;
    }
  }

  return rawTasks[pos].processed;
};

var i;
var allProcessed = true;
for (i = 0; i < rawTasks.length; i++) {
  compileTask(i);

  allProcessed = allProcessed && rawTasks[i].processed;
}
return allProcessed;

};

exports.default = {

clear: clear,
setDateFormat: setDateFormat,
getDateFormat: getDateFormat,
setTitle: setTitle,
getTitle: getTitle,
addSection: addSection,
getTasks: getTasks,
addTask: addTask,
findTaskById: findTaskById,
addTaskOrg: addTaskOrg

};

/***/ }), /* 169 */ /***/ (function(module, exports, webpack_require) {

“use strict”; /* WEBPACK VAR INJECTION */(function(process, module) {

/* parser generated by jison 0.4.17 */ /*

Returns a Parser object of the following structure:

Parser: {
  yy: {}
}

Parser.prototype: {
  yy: {},
  trace: function(),
  symbols_: {associative list: name ==> number},
  terminals_: {associative list: number ==> name},
  productions_: [...],
  performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
  table: [...],
  defaultActions: {...},
  parseError: function(str, hash),
  parse: function(input),

  lexer: {
      EOF: 1,
      parseError: function(str, hash),
      setInput: function(input),
      input: function(),
      unput: function(str),
      more: function(),
      less: function(n),
      pastInput: function(),
      upcomingInput: function(),
      showPosition: function(),
      test_match: function(regex_match_array, rule_index),
      next: function(),
      lex: function(),
      begin: function(condition),
      popState: function(),
      _currentRules: function(),
      topState: function(),
      pushState: function(condition),

      options: {
          ranges: boolean           (optional: true ==> token location info will include a .range[] member)
          flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
          backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
      },

      performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
      rules: [...],
      conditions: {associative list: name ==> set},
  }
}

token location info (@$, _$, etc.): {
  first_line: n,
  last_line: n,
  first_column: n,
  last_column: n,
  range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
}

the parseError function receives a 'hash' object with these members for lexer and parser errors: {
  text:        (matched text)
  token:       (the produced terminal token, if any)
  line:        (yylineno)
}
while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
  loc:         (yylloc)
  expected:    (string describing the set of expected tokens)
  recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
}

*/ var parser = function () {

var o = function o(k, v, _o, l) {
    for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v) {}return _o;
},
    $V0 = [1, 11],
    $V1 = [1, 12],
    $V2 = [1, 13],
    $V3 = [1, 15],
    $V4 = [1, 16],
    $V5 = [1, 17],
    $V6 = [6, 8],
    $V7 = [1, 26],
    $V8 = [1, 27],
    $V9 = [1, 28],
    $Va = [1, 29],
    $Vb = [1, 30],
    $Vc = [1, 31],
    $Vd = [6, 8, 13, 17, 23, 26, 27, 28, 29, 30, 31],
    $Ve = [6, 8, 13, 17, 23, 26, 27, 28, 29, 30, 31, 45, 46, 47],
    $Vf = [23, 45, 46, 47],
    $Vg = [23, 30, 31, 45, 46, 47],
    $Vh = [23, 26, 27, 28, 29, 45, 46, 47],
    $Vi = [6, 8, 13],
    $Vj = [1, 46];
var parser = { trace: function trace() {},
    yy: {},
    symbols_: { "error": 2, "mermaidDoc": 3, "graphConfig": 4, "CLASS_DIAGRAM": 5, "NEWLINE": 6, "statements": 7, "EOF": 8, "statement": 9, "className": 10, "alphaNumToken": 11, "relationStatement": 12, "LABEL": 13, "classStatement": 14, "methodStatement": 15, "CLASS": 16, "STRUCT_START": 17, "members": 18, "STRUCT_STOP": 19, "MEMBER": 20, "SEPARATOR": 21, "relation": 22, "STR": 23, "relationType": 24, "lineType": 25, "AGGREGATION": 26, "EXTENSION": 27, "COMPOSITION": 28, "DEPENDENCY": 29, "LINE": 30, "DOTTED_LINE": 31, "commentToken": 32, "textToken": 33, "graphCodeTokens": 34, "textNoTagsToken": 35, "TAGSTART": 36, "TAGEND": 37, "==": 38, "--": 39, "PCT": 40, "DEFAULT": 41, "SPACE": 42, "MINUS": 43, "keywords": 44, "UNICODE_TEXT": 45, "NUM": 46, "ALPHA": 47, "$accept": 0, "$end": 1 },
    terminals_: { 2: "error", 5: "CLASS_DIAGRAM", 6: "NEWLINE", 8: "EOF", 13: "LABEL", 16: "CLASS", 17: "STRUCT_START", 19: "STRUCT_STOP", 20: "MEMBER", 21: "SEPARATOR", 23: "STR", 26: "AGGREGATION", 27: "EXTENSION", 28: "COMPOSITION", 29: "DEPENDENCY", 30: "LINE", 31: "DOTTED_LINE", 34: "graphCodeTokens", 36: "TAGSTART", 37: "TAGEND", 38: "==", 39: "--", 40: "PCT", 41: "DEFAULT", 42: "SPACE", 43: "MINUS", 44: "keywords", 45: "UNICODE_TEXT", 46: "NUM", 47: "ALPHA" },
    productions_: [0, [3, 1], [4, 4], [7, 1], [7, 3], [10, 2], [10, 1], [9, 1], [9, 2], [9, 1], [9, 1], [14, 2], [14, 5], [18, 1], [18, 2], [15, 1], [15, 2], [15, 1], [15, 1], [12, 3], [12, 4], [12, 4], [12, 5], [22, 3], [22, 2], [22, 2], [22, 1], [24, 1], [24, 1], [24, 1], [24, 1], [25, 1], [25, 1], [32, 1], [32, 1], [33, 1], [33, 1], [33, 1], [33, 1], [33, 1], [33, 1], [33, 1], [35, 1], [35, 1], [35, 1], [35, 1], [11, 1], [11, 1], [11, 1]],
    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
        /* this == yyval */

        var $0 = $$.length - 1;
        switch (yystate) {
            case 5:
                this.$ = $$[$0 - 1] + $$[$0];
                break;
            case 6:
                this.$ = $$[$0];
                break;
            case 7:
                yy.addRelation($$[$0]);
                break;
            case 8:
                $$[$0 - 1].title = yy.cleanupLabel($$[$0]);yy.addRelation($$[$0 - 1]);
                break;
            case 12:
                /*console.log($$[$0-3],JSON.stringify($$[$0-1]));*/yy.addMembers($$[$0 - 3], $$[$0 - 1]);
                break;
            case 13:
                this.$ = [$$[$0]];
                break;
            case 14:
                $$[$0].push($$[$0 - 1]);this.$ = $$[$0];
                break;
            case 15:
                /*console.log('Rel found',$$[$0]);*/
                break;
            case 16:
                yy.addMembers($$[$0 - 1], yy.cleanupLabel($$[$0]));
                break;
            case 17:
                console.warn('Member', $$[$0]);
                break;
            case 18:
                /*console.log('sep found',$$[$0]);*/
                break;
            case 19:
                this.$ = { 'id1': $$[$0 - 2], 'id2': $$[$0], relation: $$[$0 - 1], relationTitle1: 'none', relationTitle2: 'none' };
                break;
            case 20:
                this.$ = { id1: $$[$0 - 3], id2: $$[$0], relation: $$[$0 - 1], relationTitle1: $$[$0 - 2], relationTitle2: 'none' };
                break;
            case 21:
                this.$ = { id1: $$[$0 - 3], id2: $$[$0], relation: $$[$0 - 2], relationTitle1: 'none', relationTitle2: $$[$0 - 1] };
                break;
            case 22:
                this.$ = { id1: $$[$0 - 4], id2: $$[$0], relation: $$[$0 - 2], relationTitle1: $$[$0 - 3], relationTitle2: $$[$0 - 1] };
                break;
            case 23:
                this.$ = { type1: $$[$0 - 2], type2: $$[$0], lineType: $$[$0 - 1] };
                break;
            case 24:
                this.$ = { type1: 'none', type2: $$[$0], lineType: $$[$0 - 1] };
                break;
            case 25:
                this.$ = { type1: $$[$0 - 1], type2: 'none', lineType: $$[$0] };
                break;
            case 26:
                this.$ = { type1: 'none', type2: 'none', lineType: $$[$0] };
                break;
            case 27:
                this.$ = yy.relationType.AGGREGATION;
                break;
            case 28:
                this.$ = yy.relationType.EXTENSION;
                break;
            case 29:
                this.$ = yy.relationType.COMPOSITION;
                break;
            case 30:
                this.$ = yy.relationType.DEPENDENCY;
                break;
            case 31:
                this.$ = yy.lineType.LINE;
                break;
            case 32:
                this.$ = yy.lineType.DOTTED_LINE;
                break;
        }
    },
    table: [{ 3: 1, 4: 2, 5: [1, 3] }, { 1: [3] }, { 1: [2, 1] }, { 6: [1, 4] }, { 7: 5, 9: 6, 10: 10, 11: 14, 12: 7, 14: 8, 15: 9, 16: $V0, 20: $V1, 21: $V2, 45: $V3, 46: $V4, 47: $V5 }, { 8: [1, 18] }, { 6: [1, 19], 8: [2, 3] }, o($V6, [2, 7], { 13: [1, 20] }), o($V6, [2, 9]), o($V6, [2, 10]), o($V6, [2, 15], { 22: 21, 24: 24, 25: 25, 13: [1, 23], 23: [1, 22], 26: $V7, 27: $V8, 28: $V9, 29: $Va, 30: $Vb, 31: $Vc }), { 10: 32, 11: 14, 45: $V3, 46: $V4, 47: $V5 }, o($V6, [2, 17]), o($V6, [2, 18]), o($Vd, [2, 6], { 11: 14, 10: 33, 45: $V3, 46: $V4, 47: $V5 }), o($Ve, [2, 46]), o($Ve, [2, 47]), o($Ve, [2, 48]), { 1: [2, 2] }, { 7: 34, 9: 6, 10: 10, 11: 14, 12: 7, 14: 8, 15: 9, 16: $V0, 20: $V1, 21: $V2, 45: $V3, 46: $V4, 47: $V5 }, o($V6, [2, 8]), { 10: 35, 11: 14, 23: [1, 36], 45: $V3, 46: $V4, 47: $V5 }, { 22: 37, 24: 24, 25: 25, 26: $V7, 27: $V8, 28: $V9, 29: $Va, 30: $Vb, 31: $Vc }, o($V6, [2, 16]), { 25: 38, 30: $Vb, 31: $Vc }, o($Vf, [2, 26], { 24: 39, 26: $V7, 27: $V8, 28: $V9, 29: $Va }), o($Vg, [2, 27]), o($Vg, [2, 28]), o($Vg, [2, 29]), o($Vg, [2, 30]), o($Vh, [2, 31]), o($Vh, [2, 32]), o($V6, [2, 11], { 17: [1, 40] }), o($Vd, [2, 5]), { 8: [2, 4] }, o($Vi, [2, 19]), { 10: 41, 11: 14, 45: $V3, 46: $V4, 47: $V5 }, { 10: 42, 11: 14, 23: [1, 43], 45: $V3, 46: $V4, 47: $V5 }, o($Vf, [2, 25], { 24: 44, 26: $V7, 27: $V8, 28: $V9, 29: $Va }), o($Vf, [2, 24]), { 18: 45, 20: $Vj }, o($Vi, [2, 21]), o($Vi, [2, 20]), { 10: 47, 11: 14, 45: $V3, 46: $V4, 47: $V5 }, o($Vf, [2, 23]), { 19: [1, 48] }, { 18: 49, 19: [2, 13], 20: $Vj }, o($Vi, [2, 22]), o($V6, [2, 12]), { 19: [2, 14] }],
    defaultActions: { 2: [2, 1], 18: [2, 2], 34: [2, 4], 49: [2, 14] },
    parseError: function parseError(str, hash) {
        if (hash.recoverable) {
            this.trace(str);
        } else {
            var _parseError = function _parseError(msg, hash) {
                this.message = msg;
                this.hash = hash;
            };

            _parseError.prototype = Error;

            throw new _parseError(str, hash);
        }
    },
    parse: function parse(input) {
        var self = this,
            stack = [0],
            tstack = [],
            vstack = [null],
            lstack = [],
            table = this.table,
            yytext = '',
            yylineno = 0,
            yyleng = 0,
            recovering = 0,
            TERROR = 2,
            EOF = 1;
        var args = lstack.slice.call(arguments, 1);
        var lexer = Object.create(this.lexer);
        var sharedState = { yy: {} };
        for (var k in this.yy) {
            if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
                sharedState.yy[k] = this.yy[k];
            }
        }
        lexer.setInput(input, sharedState.yy);
        sharedState.yy.lexer = lexer;
        sharedState.yy.parser = this;
        if (typeof lexer.yylloc == 'undefined') {
            lexer.yylloc = {};
        }
        var yyloc = lexer.yylloc;
        lstack.push(yyloc);
        var ranges = lexer.options && lexer.options.ranges;
        if (typeof sharedState.yy.parseError === 'function') {
            this.parseError = sharedState.yy.parseError;
        } else {
            this.parseError = Object.getPrototypeOf(this).parseError;
        }
        function popStack(n) {
            stack.length = stack.length - 2 * n;
            vstack.length = vstack.length - n;
            lstack.length = lstack.length - n;
        }
        function lex() {
            var token;
            token = tstack.pop() || lexer.lex() || EOF;
            if (typeof token !== 'number') {
                if (token instanceof Array) {
                    tstack = token;
                    token = tstack.pop();
                }
                token = self.symbols_[token] || token;
            }
            return token;
        }
        var symbol,
            preErrorSymbol,
            state,
            action,
            a,
            r,
            yyval = {},
            p,
            len,
            newState,
            expected;
        while (true) {
            state = stack[stack.length - 1];
            if (this.defaultActions[state]) {
                action = this.defaultActions[state];
            } else {
                if (symbol === null || typeof symbol == 'undefined') {
                    symbol = lex();
                }
                action = table[state] && table[state][symbol];
            }
            if (typeof action === 'undefined' || !action.length || !action[0]) {
                var errStr = '';
                expected = [];
                for (p in table[state]) {
                    if (this.terminals_[p] && p > TERROR) {
                        expected.push('\'' + this.terminals_[p] + '\'');
                    }
                }
                if (lexer.showPosition) {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
                } else {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
                }
                this.parseError(errStr, {
                    text: lexer.match,
                    token: this.terminals_[symbol] || symbol,
                    line: lexer.yylineno,
                    loc: yyloc,
                    expected: expected
                });
            }
            if (action[0] instanceof Array && action.length > 1) {
                throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
            }
            switch (action[0]) {
                case 1:
                    stack.push(symbol);
                    vstack.push(lexer.yytext);
                    lstack.push(lexer.yylloc);
                    stack.push(action[1]);
                    symbol = null;
                    if (!preErrorSymbol) {
                        yyleng = lexer.yyleng;
                        yytext = lexer.yytext;
                        yylineno = lexer.yylineno;
                        yyloc = lexer.yylloc;
                        if (recovering > 0) {
                            recovering--;
                        }
                    } else {
                        symbol = preErrorSymbol;
                        preErrorSymbol = null;
                    }
                    break;
                case 2:
                    len = this.productions_[action[1]][1];
                    yyval.$ = vstack[vstack.length - len];
                    yyval._$ = {
                        first_line: lstack[lstack.length - (len || 1)].first_line,
                        last_line: lstack[lstack.length - 1].last_line,
                        first_column: lstack[lstack.length - (len || 1)].first_column,
                        last_column: lstack[lstack.length - 1].last_column
                    };
                    if (ranges) {
                        yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
                    }
                    r = this.performAction.apply(yyval, [yytext, yyleng, yylineno, sharedState.yy, action[1], vstack, lstack].concat(args));
                    if (typeof r !== 'undefined') {
                        return r;
                    }
                    if (len) {
                        stack = stack.slice(0, -1 * len * 2);
                        vstack = vstack.slice(0, -1 * len);
                        lstack = lstack.slice(0, -1 * len);
                    }
                    stack.push(this.productions_[action[1]][0]);
                    vstack.push(yyval.$);
                    lstack.push(yyval._$);
                    newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
                    stack.push(newState);
                    break;
                case 3:
                    return true;
            }
        }
        return true;
    } };

/* generated by jison-lex 0.3.4 */
var lexer = function () {
    var lexer = {

        EOF: 1,

        parseError: function parseError(str, hash) {
            if (this.yy.parser) {
                this.yy.parser.parseError(str, hash);
            } else {
                throw new Error(str);
            }
        },

        // resets the lexer, sets new input
        setInput: function setInput(input, yy) {
            this.yy = yy || this.yy || {};
            this._input = input;
            this._more = this._backtrack = this.done = false;
            this.yylineno = this.yyleng = 0;
            this.yytext = this.matched = this.match = '';
            this.conditionStack = ['INITIAL'];
            this.yylloc = {
                first_line: 1,
                first_column: 0,
                last_line: 1,
                last_column: 0
            };
            if (this.options.ranges) {
                this.yylloc.range = [0, 0];
            }
            this.offset = 0;
            return this;
        },

        // consumes and returns one char from the input
        input: function input() {
            var ch = this._input[0];
            this.yytext += ch;
            this.yyleng++;
            this.offset++;
            this.match += ch;
            this.matched += ch;
            var lines = ch.match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno++;
                this.yylloc.last_line++;
            } else {
                this.yylloc.last_column++;
            }
            if (this.options.ranges) {
                this.yylloc.range[1]++;
            }

            this._input = this._input.slice(1);
            return ch;
        },

        // unshifts one char (or a string) into the input
        unput: function unput(ch) {
            var len = ch.length;
            var lines = ch.split(/(?:\r\n?|\n)/g);

            this._input = ch + this._input;
            this.yytext = this.yytext.substr(0, this.yytext.length - len);
            //this.yyleng -= len;
            this.offset -= len;
            var oldLines = this.match.split(/(?:\r\n?|\n)/g);
            this.match = this.match.substr(0, this.match.length - 1);
            this.matched = this.matched.substr(0, this.matched.length - 1);

            if (lines.length - 1) {
                this.yylineno -= lines.length - 1;
            }
            var r = this.yylloc.range;

            this.yylloc = {
                first_line: this.yylloc.first_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.first_column,
                last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
            };

            if (this.options.ranges) {
                this.yylloc.range = [r[0], r[0] + this.yyleng - len];
            }
            this.yyleng = this.yytext.length;
            return this;
        },

        // When called from action, caches matched text and appends it on next action
        more: function more() {
            this._more = true;
            return this;
        },

        // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
        reject: function reject() {
            if (this.options.backtrack_lexer) {
                this._backtrack = true;
            } else {
                return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
            }
            return this;
        },

        // retain first n characters of the match
        less: function less(n) {
            this.unput(this.match.slice(n));
        },

        // displays already matched input, i.e. for error messages
        pastInput: function pastInput() {
            var past = this.matched.substr(0, this.matched.length - this.match.length);
            return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, "");
        },

        // displays upcoming input, i.e. for error messages
        upcomingInput: function upcomingInput() {
            var next = this.match;
            if (next.length < 20) {
                next += this._input.substr(0, 20 - next.length);
            }
            return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
        },

        // displays the character position where the lexing error occurred, i.e. for error messages
        showPosition: function showPosition() {
            var pre = this.pastInput();
            var c = new Array(pre.length + 1).join("-");
            return pre + this.upcomingInput() + "\n" + c + "^";
        },

        // test the lexed token: return FALSE when not a match, otherwise return token
        test_match: function test_match(match, indexed_rule) {
            var token, lines, backup;

            if (this.options.backtrack_lexer) {
                // save context
                backup = {
                    yylineno: this.yylineno,
                    yylloc: {
                        first_line: this.yylloc.first_line,
                        last_line: this.last_line,
                        first_column: this.yylloc.first_column,
                        last_column: this.yylloc.last_column
                    },
                    yytext: this.yytext,
                    match: this.match,
                    matches: this.matches,
                    matched: this.matched,
                    yyleng: this.yyleng,
                    offset: this.offset,
                    _more: this._more,
                    _input: this._input,
                    yy: this.yy,
                    conditionStack: this.conditionStack.slice(0),
                    done: this.done
                };
                if (this.options.ranges) {
                    backup.yylloc.range = this.yylloc.range.slice(0);
                }
            }

            lines = match[0].match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno += lines.length;
            }
            this.yylloc = {
                first_line: this.yylloc.last_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.last_column,
                last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
            };
            this.yytext += match[0];
            this.match += match[0];
            this.matches = match;
            this.yyleng = this.yytext.length;
            if (this.options.ranges) {
                this.yylloc.range = [this.offset, this.offset += this.yyleng];
            }
            this._more = false;
            this._backtrack = false;
            this._input = this._input.slice(match[0].length);
            this.matched += match[0];
            token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
            if (this.done && this._input) {
                this.done = false;
            }
            if (token) {
                return token;
            } else if (this._backtrack) {
                // recover context
                for (var k in backup) {
                    this[k] = backup[k];
                }
                return false; // rule action called reject() implying the next rule should be tested instead.
            }
            return false;
        },

        // return next match in input
        next: function next() {
            if (this.done) {
                return this.EOF;
            }
            if (!this._input) {
                this.done = true;
            }

            var token, match, tempMatch, index;
            if (!this._more) {
                this.yytext = '';
                this.match = '';
            }
            var rules = this._currentRules();
            for (var i = 0; i < rules.length; i++) {
                tempMatch = this._input.match(this.rules[rules[i]]);
                if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                    match = tempMatch;
                    index = i;
                    if (this.options.backtrack_lexer) {
                        token = this.test_match(tempMatch, rules[i]);
                        if (token !== false) {
                            return token;
                        } else if (this._backtrack) {
                            match = false;
                            continue; // rule action called reject() implying a rule MISmatch.
                        } else {
                            // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                            return false;
                        }
                    } else if (!this.options.flex) {
                        break;
                    }
                }
            }
            if (match) {
                token = this.test_match(match, rules[index]);
                if (token !== false) {
                    return token;
                }
                // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                return false;
            }
            if (this._input === "") {
                return this.EOF;
            } else {
                return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
            }
        },

        // return next match that has a token
        lex: function lex() {
            var r = this.next();
            if (r) {
                return r;
            } else {
                return this.lex();
            }
        },

        // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
        begin: function begin(condition) {
            this.conditionStack.push(condition);
        },

        // pop the previously active lexer condition state off the condition stack
        popState: function popState() {
            var n = this.conditionStack.length - 1;
            if (n > 0) {
                return this.conditionStack.pop();
            } else {
                return this.conditionStack[0];
            }
        },

        // produce the lexer rule set which is active for the currently active lexer condition state
        _currentRules: function _currentRules() {
            if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
                return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
            } else {
                return this.conditions["INITIAL"].rules;
            }
        },

        // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
        topState: function topState(n) {
            n = this.conditionStack.length - 1 - Math.abs(n || 0);
            if (n >= 0) {
                return this.conditionStack[n];
            } else {
                return "INITIAL";
            }
        },

        // alias for begin(condition)
        pushState: function pushState(condition) {
            this.begin(condition);
        },

        // return the number of states currently on the stack
        stateStackSize: function stateStackSize() {
            return this.conditionStack.length;
        },
        options: {},
        performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
            var YYSTATE = YY_START;
            switch ($avoiding_name_collisions) {
                case 0:
                    /* do nothing */
                    break;
                case 1:
                    return 6;
                    break;
                case 2:
                    /* skip whitespace */
                    break;
                case 3:
                    return 5;
                    break;
                case 4:
                    this.begin("struct"); /*console.log('Starting struct');*/return 17;
                    break;
                case 5:
                    /*console.log('Ending struct');*/this.popState();return 19;
                    break;
                case 6:
                    /* nothing */
                    break;
                case 7:
                    /*console.log('lex-member: ' + yy_.yytext);*/return "MEMBER";
                    break;
                case 8:
                    return 16;
                    break;
                case 9:
                    this.begin("string");
                    break;
                case 10:
                    this.popState();
                    break;
                case 11:
                    return "STR";
                    break;
                case 12:
                    return 27;
                    break;
                case 13:
                    return 27;
                    break;
                case 14:
                    return 29;
                    break;
                case 15:
                    return 29;
                    break;
                case 16:
                    return 28;
                    break;
                case 17:
                    return 26;
                    break;
                case 18:
                    return 30;
                    break;
                case 19:
                    return 31;
                    break;
                case 20:
                    return 13;
                    break;
                case 21:
                    return 43;
                    break;
                case 22:
                    return 'DOT';
                    break;
                case 23:
                    return 'PLUS';
                    break;
                case 24:
                    return 40;
                    break;
                case 25:
                    return 'EQUALS';
                    break;
                case 26:
                    return 'EQUALS';
                    break;
                case 27:
                    return 47;
                    break;
                case 28:
                    return 'PUNCTUATION';
                    break;
                case 29:
                    return 46;
                    break;
                case 30:
                    return 45;
                    break;
                case 31:
                    return 42;
                    break;
                case 32:
                    return 8;
                    break;
            }
        },
        rules: [/^(?:%%[^\n]*)/, /^(?:\n+)/, /^(?:\s+)/, /^(?:classDiagram\b)/, /^(?:[\{])/, /^(?:\})/, /^(?:[\n])/, /^(?:[^\{\}\n]*)/, /^(?:class\b)/, /^(?:["])/, /^(?:["])/, /^(?:[^"]*)/, /^(?:\s*<\|)/, /^(?:\s*\|>)/, /^(?:\s*>)/, /^(?:\s*<)/, /^(?:\s*\*)/, /^(?:\s*o\b)/, /^(?:--)/, /^(?:\.\.)/, /^(?::[^#\n;]+)/, /^(?:-)/, /^(?:\.)/, /^(?:\+)/, /^(?:%)/, /^(?:=)/, /^(?:=)/, /^(?:[A-Za-z]+)/, /^(?:[!"#$%&'*+,-.`?\\_\/])/, /^(?:[0-9]+)/, /^(?:[\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6]|[\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377]|[\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5]|[\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA]|[\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE]|[\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA]|[\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0]|[\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977]|[\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2]|[\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A]|[\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39]|[\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8]|[\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C]|[\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C]|[\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99]|[\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0]|[\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D]|[\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3]|[\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10]|[\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1]|[\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81]|[\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3]|[\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6]|[\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A]|[\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081]|[\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D]|[\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0]|[\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310]|[\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C]|[\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u1700-\u170C\u170E-\u1711]|[\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7]|[\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C]|[\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16]|[\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF]|[\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC]|[\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D]|[\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D]|[\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3]|[\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F]|[\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128]|[\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184]|[\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3]|[\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6]|[\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE]|[\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C]|[\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D]|[\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC]|[\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B]|[\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788]|[\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805]|[\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB]|[\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28]|[\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5]|[\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4]|[\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E]|[\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D]|[\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36]|[\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D]|[\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC]|[\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF]|[\uFFD2-\uFFD7\uFFDA-\uFFDC])/, /^(?:\s)/, /^(?:$)/],
        conditions: { "string": { "rules": [10, 11], "inclusive": false }, "struct": { "rules": [5, 6, 7], "inclusive": false }, "INITIAL": { "rules": [0, 1, 2, 3, 4, 8, 9, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32], "inclusive": true } }
    };
    return lexer;
}();
parser.lexer = lexer;
function Parser() {
    this.yy = {};
}
Parser.prototype = parser;parser.Parser = Parser;
return new Parser();

}();

if (true) {

exports.parser = parser;
exports.Parser = parser.Parser;
exports.parse = function () {
    return parser.parse.apply(parser, arguments);
};
exports.main = function commonjsMain(args) {
    if (!args[1]) {
        console.log('Usage: ' + args[0] + ' FILE');
        process.exit(1);
    }
    var source = __webpack_require__(8).readFileSync(__webpack_require__(9).normalize(args[1]), "utf8");
    return exports.parser.parse(source);
};
if (typeof module !== 'undefined' && __webpack_require__.c[__webpack_require__.s] === module) {
    exports.main(process.argv.slice(1));
}

} /* WEBPACK VAR INJECTION */}.call(exports, webpack_require(7), webpack_require(3)(module)))

/***/ }), /* 170 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.relationType = exports.lineType = exports.cleanupLabel = exports.addMembers = exports.addRelation = exports.getRelations = exports.getClasses = exports.getClass = exports.clear = exports.addClass = undefined;

var _logger = webpack_require(1);

var relations = [];

var classes; classes = {};

/**

* Function called by parser when a node definition has been found.
* @param id
* @param text
* @param type
* @param style
*/

var addClass = exports.addClass = function addClass(id) {

if (typeof classes[id] === 'undefined') {
  classes[id] = {
    id: id,
    methods: [],
    members: []
  };
}

};

var clear = exports.clear = function clear() {

relations = [];
classes = {};

};

var getClass = exports.getClass = function getClass(id) {

return classes[id];

}; var getClasses = exports.getClasses = function getClasses() {

return classes;

};

var getRelations = exports.getRelations = function getRelations() {

return relations;

};

var addRelation = exports.addRelation = function addRelation(relation) {

_logger.logger.warn('Adding relation: ' + JSON.stringify(relation));
addClass(relation.id1);
addClass(relation.id2);
relations.push(relation);

};

var addMembers = exports.addMembers = function addMembers(className, MembersArr) {

var theClass = classes[className];
if (typeof MembersArr === 'string') {
  if (MembersArr.substr(-1) === ')') {
    theClass.methods.push(MembersArr);
  } else {
    theClass.members.push(MembersArr);
  }
}

};

var cleanupLabel = exports.cleanupLabel = function cleanupLabel(label) {

if (label.substring(0, 1) === ':') {
  return label.substr(2).trim();
} else {
  return label.trim();
}

};

var lineType = exports.lineType = {

LINE: 0,
DOTTED_LINE: 1

};

var relationType = exports.relationType = {

AGGREGATION: 0,
EXTENSION: 1,
COMPOSITION: 2,
DEPENDENCY: 3

};

exports.default = {

addClass: addClass,
clear: clear,
getClass: getClass,
getClasses: getClasses,
getRelations: getRelations,
addRelation: addRelation,
addMembers: addMembers,
cleanupLabel: cleanupLabel,
lineType: lineType,
relationType: relationType

};

/***/ }), /* 171 */ /***/ (function(module, exports, webpack_require) {

“use strict”; /* WEBPACK VAR INJECTION */(function(process, module) {

/* parser generated by jison 0.4.17 */ /*

Returns a Parser object of the following structure:

Parser: {
  yy: {}
}

Parser.prototype: {
  yy: {},
  trace: function(),
  symbols_: {associative list: name ==> number},
  terminals_: {associative list: number ==> name},
  productions_: [...],
  performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
  table: [...],
  defaultActions: {...},
  parseError: function(str, hash),
  parse: function(input),

  lexer: {
      EOF: 1,
      parseError: function(str, hash),
      setInput: function(input),
      input: function(),
      unput: function(str),
      more: function(),
      less: function(n),
      pastInput: function(),
      upcomingInput: function(),
      showPosition: function(),
      test_match: function(regex_match_array, rule_index),
      next: function(),
      lex: function(),
      begin: function(condition),
      popState: function(),
      _currentRules: function(),
      topState: function(),
      pushState: function(condition),

      options: {
          ranges: boolean           (optional: true ==> token location info will include a .range[] member)
          flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
          backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
      },

      performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
      rules: [...],
      conditions: {associative list: name ==> set},
  }
}

token location info (@$, _$, etc.): {
  first_line: n,
  last_line: n,
  first_column: n,
  last_column: n,
  range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
}

the parseError function receives a 'hash' object with these members for lexer and parser errors: {
  text:        (matched text)
  token:       (the produced terminal token, if any)
  line:        (yylineno)
}
while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
  loc:         (yylloc)
  expected:    (string describing the set of expected tokens)
  recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
}

*/ var parser = function () {

var o = function o(k, v, _o, l) {
    for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v) {}return _o;
},
    $V0 = [2, 3],
    $V1 = [1, 7],
    $V2 = [7, 12, 15, 17, 19, 20, 21],
    $V3 = [7, 11, 12, 15, 17, 19, 20, 21],
    $V4 = [2, 20],
    $V5 = [1, 32];
var parser = { trace: function trace() {},
    yy: {},
    symbols_: { "error": 2, "start": 3, "GG": 4, ":": 5, "document": 6, "EOF": 7, "DIR": 8, "options": 9, "body": 10, "OPT": 11, "NL": 12, "line": 13, "statement": 14, "COMMIT": 15, "commit_arg": 16, "BRANCH": 17, "ID": 18, "CHECKOUT": 19, "MERGE": 20, "RESET": 21, "reset_arg": 22, "STR": 23, "HEAD": 24, "reset_parents": 25, "CARET": 26, "$accept": 0, "$end": 1 },
    terminals_: { 2: "error", 4: "GG", 5: ":", 7: "EOF", 8: "DIR", 11: "OPT", 12: "NL", 15: "COMMIT", 17: "BRANCH", 18: "ID", 19: "CHECKOUT", 20: "MERGE", 21: "RESET", 23: "STR", 24: "HEAD", 26: "CARET" },
    productions_: [0, [3, 4], [3, 5], [6, 0], [6, 2], [9, 2], [9, 1], [10, 0], [10, 2], [13, 2], [13, 1], [14, 2], [14, 2], [14, 2], [14, 2], [14, 2], [16, 0], [16, 1], [22, 2], [22, 2], [25, 0], [25, 2]],
    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
        /* this == yyval */

        var $0 = $$.length - 1;
        switch (yystate) {
            case 1:
                return $$[$0 - 1];
                break;
            case 2:
                yy.setDirection($$[$0 - 3]);return $$[$0 - 1];
                break;
            case 4:
                yy.setOptions($$[$0 - 1]);this.$ = $$[$0];
                break;
            case 5:
                $$[$0 - 1] += $$[$0];this.$ = $$[$0 - 1];
                break;
            case 7:
                this.$ = [];
                break;
            case 8:
                $$[$0 - 1].push($$[$0]);this.$ = $$[$0 - 1];
                break;
            case 9:
                this.$ = $$[$0 - 1];
                break;
            case 11:
                yy.commit($$[$0]);
                break;
            case 12:
                yy.branch($$[$0]);
                break;
            case 13:
                yy.checkout($$[$0]);
                break;
            case 14:
                yy.merge($$[$0]);
                break;
            case 15:
                yy.reset($$[$0]);
                break;
            case 16:
                this.$ = "";
                break;
            case 17:
                this.$ = $$[$0];
                break;
            case 18:
                this.$ = $$[$0 - 1] + ":" + $$[$0];
                break;
            case 19:
                this.$ = $$[$0 - 1] + ":" + yy.count;yy.count = 0;
                break;
            case 20:
                yy.count = 0;
                break;
            case 21:
                yy.count += 1;
                break;
        }
    },
    table: [{ 3: 1, 4: [1, 2] }, { 1: [3] }, { 5: [1, 3], 8: [1, 4] }, { 6: 5, 7: $V0, 9: 6, 12: $V1 }, { 5: [1, 8] }, { 7: [1, 9] }, o($V2, [2, 7], { 10: 10, 11: [1, 11] }), o($V3, [2, 6]), { 6: 12, 7: $V0, 9: 6, 12: $V1 }, { 1: [2, 1] }, { 7: [2, 4], 12: [1, 15], 13: 13, 14: 14, 15: [1, 16], 17: [1, 17], 19: [1, 18], 20: [1, 19], 21: [1, 20] }, o($V3, [2, 5]), { 7: [1, 21] }, o($V2, [2, 8]), { 12: [1, 22] }, o($V2, [2, 10]), { 12: [2, 16], 16: 23, 23: [1, 24] }, { 18: [1, 25] }, { 18: [1, 26] }, { 18: [1, 27] }, { 18: [1, 30], 22: 28, 24: [1, 29] }, { 1: [2, 2] }, o($V2, [2, 9]), { 12: [2, 11] }, { 12: [2, 17] }, { 12: [2, 12] }, { 12: [2, 13] }, { 12: [2, 14] }, { 12: [2, 15] }, { 12: $V4, 25: 31, 26: $V5 }, { 12: $V4, 25: 33, 26: $V5 }, { 12: [2, 18] }, { 12: $V4, 25: 34, 26: $V5 }, { 12: [2, 19] }, { 12: [2, 21] }],
    defaultActions: { 9: [2, 1], 21: [2, 2], 23: [2, 11], 24: [2, 17], 25: [2, 12], 26: [2, 13], 27: [2, 14], 28: [2, 15], 31: [2, 18], 33: [2, 19], 34: [2, 21] },
    parseError: function parseError(str, hash) {
        if (hash.recoverable) {
            this.trace(str);
        } else {
            var _parseError = function _parseError(msg, hash) {
                this.message = msg;
                this.hash = hash;
            };

            _parseError.prototype = Error;

            throw new _parseError(str, hash);
        }
    },
    parse: function parse(input) {
        var self = this,
            stack = [0],
            tstack = [],
            vstack = [null],
            lstack = [],
            table = this.table,
            yytext = '',
            yylineno = 0,
            yyleng = 0,
            recovering = 0,
            TERROR = 2,
            EOF = 1;
        var args = lstack.slice.call(arguments, 1);
        var lexer = Object.create(this.lexer);
        var sharedState = { yy: {} };
        for (var k in this.yy) {
            if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
                sharedState.yy[k] = this.yy[k];
            }
        }
        lexer.setInput(input, sharedState.yy);
        sharedState.yy.lexer = lexer;
        sharedState.yy.parser = this;
        if (typeof lexer.yylloc == 'undefined') {
            lexer.yylloc = {};
        }
        var yyloc = lexer.yylloc;
        lstack.push(yyloc);
        var ranges = lexer.options && lexer.options.ranges;
        if (typeof sharedState.yy.parseError === 'function') {
            this.parseError = sharedState.yy.parseError;
        } else {
            this.parseError = Object.getPrototypeOf(this).parseError;
        }
        function popStack(n) {
            stack.length = stack.length - 2 * n;
            vstack.length = vstack.length - n;
            lstack.length = lstack.length - n;
        }
        function lex() {
            var token;
            token = tstack.pop() || lexer.lex() || EOF;
            if (typeof token !== 'number') {
                if (token instanceof Array) {
                    tstack = token;
                    token = tstack.pop();
                }
                token = self.symbols_[token] || token;
            }
            return token;
        }
        var symbol,
            preErrorSymbol,
            state,
            action,
            a,
            r,
            yyval = {},
            p,
            len,
            newState,
            expected;
        while (true) {
            state = stack[stack.length - 1];
            if (this.defaultActions[state]) {
                action = this.defaultActions[state];
            } else {
                if (symbol === null || typeof symbol == 'undefined') {
                    symbol = lex();
                }
                action = table[state] && table[state][symbol];
            }
            if (typeof action === 'undefined' || !action.length || !action[0]) {
                var errStr = '';
                expected = [];
                for (p in table[state]) {
                    if (this.terminals_[p] && p > TERROR) {
                        expected.push('\'' + this.terminals_[p] + '\'');
                    }
                }
                if (lexer.showPosition) {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
                } else {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
                }
                this.parseError(errStr, {
                    text: lexer.match,
                    token: this.terminals_[symbol] || symbol,
                    line: lexer.yylineno,
                    loc: yyloc,
                    expected: expected
                });
            }
            if (action[0] instanceof Array && action.length > 1) {
                throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
            }
            switch (action[0]) {
                case 1:
                    stack.push(symbol);
                    vstack.push(lexer.yytext);
                    lstack.push(lexer.yylloc);
                    stack.push(action[1]);
                    symbol = null;
                    if (!preErrorSymbol) {
                        yyleng = lexer.yyleng;
                        yytext = lexer.yytext;
                        yylineno = lexer.yylineno;
                        yyloc = lexer.yylloc;
                        if (recovering > 0) {
                            recovering--;
                        }
                    } else {
                        symbol = preErrorSymbol;
                        preErrorSymbol = null;
                    }
                    break;
                case 2:
                    len = this.productions_[action[1]][1];
                    yyval.$ = vstack[vstack.length - len];
                    yyval._$ = {
                        first_line: lstack[lstack.length - (len || 1)].first_line,
                        last_line: lstack[lstack.length - 1].last_line,
                        first_column: lstack[lstack.length - (len || 1)].first_column,
                        last_column: lstack[lstack.length - 1].last_column
                    };
                    if (ranges) {
                        yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
                    }
                    r = this.performAction.apply(yyval, [yytext, yyleng, yylineno, sharedState.yy, action[1], vstack, lstack].concat(args));
                    if (typeof r !== 'undefined') {
                        return r;
                    }
                    if (len) {
                        stack = stack.slice(0, -1 * len * 2);
                        vstack = vstack.slice(0, -1 * len);
                        lstack = lstack.slice(0, -1 * len);
                    }
                    stack.push(this.productions_[action[1]][0]);
                    vstack.push(yyval.$);
                    lstack.push(yyval._$);
                    newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
                    stack.push(newState);
                    break;
                case 3:
                    return true;
            }
        }
        return true;
    } };
/* generated by jison-lex 0.3.4 */
var lexer = function () {
    var lexer = {

        EOF: 1,

        parseError: function parseError(str, hash) {
            if (this.yy.parser) {
                this.yy.parser.parseError(str, hash);
            } else {
                throw new Error(str);
            }
        },

        // resets the lexer, sets new input
        setInput: function setInput(input, yy) {
            this.yy = yy || this.yy || {};
            this._input = input;
            this._more = this._backtrack = this.done = false;
            this.yylineno = this.yyleng = 0;
            this.yytext = this.matched = this.match = '';
            this.conditionStack = ['INITIAL'];
            this.yylloc = {
                first_line: 1,
                first_column: 0,
                last_line: 1,
                last_column: 0
            };
            if (this.options.ranges) {
                this.yylloc.range = [0, 0];
            }
            this.offset = 0;
            return this;
        },

        // consumes and returns one char from the input
        input: function input() {
            var ch = this._input[0];
            this.yytext += ch;
            this.yyleng++;
            this.offset++;
            this.match += ch;
            this.matched += ch;
            var lines = ch.match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno++;
                this.yylloc.last_line++;
            } else {
                this.yylloc.last_column++;
            }
            if (this.options.ranges) {
                this.yylloc.range[1]++;
            }

            this._input = this._input.slice(1);
            return ch;
        },

        // unshifts one char (or a string) into the input
        unput: function unput(ch) {
            var len = ch.length;
            var lines = ch.split(/(?:\r\n?|\n)/g);

            this._input = ch + this._input;
            this.yytext = this.yytext.substr(0, this.yytext.length - len);
            //this.yyleng -= len;
            this.offset -= len;
            var oldLines = this.match.split(/(?:\r\n?|\n)/g);
            this.match = this.match.substr(0, this.match.length - 1);
            this.matched = this.matched.substr(0, this.matched.length - 1);

            if (lines.length - 1) {
                this.yylineno -= lines.length - 1;
            }
            var r = this.yylloc.range;

            this.yylloc = {
                first_line: this.yylloc.first_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.first_column,
                last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
            };

            if (this.options.ranges) {
                this.yylloc.range = [r[0], r[0] + this.yyleng - len];
            }
            this.yyleng = this.yytext.length;
            return this;
        },

        // When called from action, caches matched text and appends it on next action
        more: function more() {
            this._more = true;
            return this;
        },

        // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
        reject: function reject() {
            if (this.options.backtrack_lexer) {
                this._backtrack = true;
            } else {
                return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
            }
            return this;
        },

        // retain first n characters of the match
        less: function less(n) {
            this.unput(this.match.slice(n));
        },

        // displays already matched input, i.e. for error messages
        pastInput: function pastInput() {
            var past = this.matched.substr(0, this.matched.length - this.match.length);
            return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, "");
        },

        // displays upcoming input, i.e. for error messages
        upcomingInput: function upcomingInput() {
            var next = this.match;
            if (next.length < 20) {
                next += this._input.substr(0, 20 - next.length);
            }
            return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
        },

        // displays the character position where the lexing error occurred, i.e. for error messages
        showPosition: function showPosition() {
            var pre = this.pastInput();
            var c = new Array(pre.length + 1).join("-");
            return pre + this.upcomingInput() + "\n" + c + "^";
        },

        // test the lexed token: return FALSE when not a match, otherwise return token
        test_match: function test_match(match, indexed_rule) {
            var token, lines, backup;

            if (this.options.backtrack_lexer) {
                // save context
                backup = {
                    yylineno: this.yylineno,
                    yylloc: {
                        first_line: this.yylloc.first_line,
                        last_line: this.last_line,
                        first_column: this.yylloc.first_column,
                        last_column: this.yylloc.last_column
                    },
                    yytext: this.yytext,
                    match: this.match,
                    matches: this.matches,
                    matched: this.matched,
                    yyleng: this.yyleng,
                    offset: this.offset,
                    _more: this._more,
                    _input: this._input,
                    yy: this.yy,
                    conditionStack: this.conditionStack.slice(0),
                    done: this.done
                };
                if (this.options.ranges) {
                    backup.yylloc.range = this.yylloc.range.slice(0);
                }
            }

            lines = match[0].match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno += lines.length;
            }
            this.yylloc = {
                first_line: this.yylloc.last_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.last_column,
                last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
            };
            this.yytext += match[0];
            this.match += match[0];
            this.matches = match;
            this.yyleng = this.yytext.length;
            if (this.options.ranges) {
                this.yylloc.range = [this.offset, this.offset += this.yyleng];
            }
            this._more = false;
            this._backtrack = false;
            this._input = this._input.slice(match[0].length);
            this.matched += match[0];
            token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
            if (this.done && this._input) {
                this.done = false;
            }
            if (token) {
                return token;
            } else if (this._backtrack) {
                // recover context
                for (var k in backup) {
                    this[k] = backup[k];
                }
                return false; // rule action called reject() implying the next rule should be tested instead.
            }
            return false;
        },

        // return next match in input
        next: function next() {
            if (this.done) {
                return this.EOF;
            }
            if (!this._input) {
                this.done = true;
            }

            var token, match, tempMatch, index;
            if (!this._more) {
                this.yytext = '';
                this.match = '';
            }
            var rules = this._currentRules();
            for (var i = 0; i < rules.length; i++) {
                tempMatch = this._input.match(this.rules[rules[i]]);
                if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                    match = tempMatch;
                    index = i;
                    if (this.options.backtrack_lexer) {
                        token = this.test_match(tempMatch, rules[i]);
                        if (token !== false) {
                            return token;
                        } else if (this._backtrack) {
                            match = false;
                            continue; // rule action called reject() implying a rule MISmatch.
                        } else {
                            // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                            return false;
                        }
                    } else if (!this.options.flex) {
                        break;
                    }
                }
            }
            if (match) {
                token = this.test_match(match, rules[index]);
                if (token !== false) {
                    return token;
                }
                // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                return false;
            }
            if (this._input === "") {
                return this.EOF;
            } else {
                return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
            }
        },

        // return next match that has a token
        lex: function lex() {
            var r = this.next();
            if (r) {
                return r;
            } else {
                return this.lex();
            }
        },

        // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
        begin: function begin(condition) {
            this.conditionStack.push(condition);
        },

        // pop the previously active lexer condition state off the condition stack
        popState: function popState() {
            var n = this.conditionStack.length - 1;
            if (n > 0) {
                return this.conditionStack.pop();
            } else {
                return this.conditionStack[0];
            }
        },

        // produce the lexer rule set which is active for the currently active lexer condition state
        _currentRules: function _currentRules() {
            if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
                return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
            } else {
                return this.conditions["INITIAL"].rules;
            }
        },

        // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
        topState: function topState(n) {
            n = this.conditionStack.length - 1 - Math.abs(n || 0);
            if (n >= 0) {
                return this.conditionStack[n];
            } else {
                return "INITIAL";
            }
        },

        // alias for begin(condition)
        pushState: function pushState(condition) {
            this.begin(condition);
        },

        // return the number of states currently on the stack
        stateStackSize: function stateStackSize() {
            return this.conditionStack.length;
        },
        options: { "case-insensitive": true },
        performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
            var YYSTATE = YY_START;
            switch ($avoiding_name_collisions) {
                case 0:
                    return 12;
                    break;
                case 1:
                    /* skip all whitespace */
                    break;
                case 2:
                    /* skip comments */
                    break;
                case 3:
                    /* skip comments */
                    break;
                case 4:
                    return 4;
                    break;
                case 5:
                    return 15;
                    break;
                case 6:
                    return 17;
                    break;
                case 7:
                    return 20;
                    break;
                case 8:
                    return 21;
                    break;
                case 9:
                    return 19;
                    break;
                case 10:
                    return 8;
                    break;
                case 11:
                    return 8;
                    break;
                case 12:
                    return 5;
                    break;
                case 13:
                    return 26;
                    break;
                case 14:
                    this.begin("options");
                    break;
                case 15:
                    this.popState();
                    break;
                case 16:
                    return 11;
                    break;
                case 17:
                    this.begin("string");
                    break;
                case 18:
                    this.popState();
                    break;
                case 19:
                    return 23;
                    break;
                case 20:
                    return 18;
                    break;
                case 21:
                    return 7;
                    break;
            }
        },
        rules: [/^(?:(\r?\n)+)/i, /^(?:\s+)/i, /^(?:#[^\n]*)/i, /^(?:%[^\n]*)/i, /^(?:gitGraph\b)/i, /^(?:commit\b)/i, /^(?:branch\b)/i, /^(?:merge\b)/i, /^(?:reset\b)/i, /^(?:checkout\b)/i, /^(?:LR\b)/i, /^(?:BT\b)/i, /^(?::)/i, /^(?:\^)/i, /^(?:options\r?\n)/i, /^(?:end\r?\n)/i, /^(?:[^\n]+\r?\n)/i, /^(?:["])/i, /^(?:["])/i, /^(?:[^"]*)/i, /^(?:[a-zA-Z][a-zA-Z0-9_]+)/i, /^(?:$)/i],
        conditions: { "options": { "rules": [15, 16], "inclusive": false }, "string": { "rules": [18, 19], "inclusive": false }, "INITIAL": { "rules": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17, 20, 21], "inclusive": true } }
    };
    return lexer;
}();
parser.lexer = lexer;
function Parser() {
    this.yy = {};
}
Parser.prototype = parser;parser.Parser = Parser;
return new Parser();

}();

if (true) {

exports.parser = parser;
exports.Parser = parser.Parser;
exports.parse = function () {
    return parser.parse.apply(parser, arguments);
};
exports.main = function commonjsMain(args) {
    if (!args[1]) {
        console.log('Usage: ' + args[0] + ' FILE');
        process.exit(1);
    }
    var source = __webpack_require__(8).readFileSync(__webpack_require__(9).normalize(args[1]), "utf8");
    return exports.parser.parse(source);
};
if (typeof module !== 'undefined' && __webpack_require__.c[__webpack_require__.s] === module) {
    exports.main(process.argv.slice(1));
}

} /* WEBPACK VAR INJECTION */}.call(exports, webpack_require(7), webpack_require(3)(module)))

/***/ }), /* 172 */ /***/ (function(module, exports, webpack_require) {

module.exports = webpack_require(223);

/***/ }), /* 173 */ /***/ (function(module, exports, webpack_require) {

var baseForOwn = webpack_require(225),

createBaseEach = __webpack_require__(238);

/**

* The base implementation of `_.forEach` without support for iteratee shorthands.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array|Object} Returns `collection`.
*/

var baseEach = createBaseEach(baseForOwn);

module.exports = baseEach;

/***/ }), /* 174 */ /***/ (function(module, exports, webpack_require) {

var baseTimes = webpack_require(228),

isArguments = __webpack_require__(175),
isArray = __webpack_require__(2),
isBuffer = __webpack_require__(177),
isIndex = __webpack_require__(32),
isTypedArray = __webpack_require__(178);

/** Used for built-in method references. */ var objectProto = Object.prototype;

/** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty;

/**

* Creates an array of the enumerable property names of the array-like `value`.
*
* @private
* @param {*} value The value to query.
* @param {boolean} inherited Specify returning inherited property names.
* @returns {Array} Returns the array of property names.
*/

function arrayLikeKeys(value, inherited) {

var isArr = isArray(value),
    isArg = !isArr && isArguments(value),
    isBuff = !isArr && !isArg && isBuffer(value),
    isType = !isArr && !isArg && !isBuff && isTypedArray(value),
    skipIndexes = isArr || isArg || isBuff || isType,
    result = skipIndexes ? baseTimes(value.length, String) : [],
    length = result.length;

for (var key in value) {
  if ((inherited || hasOwnProperty.call(value, key)) &&
      !(skipIndexes && (
         // Safari 9 has enumerable `arguments.length` in strict mode.
         key == 'length' ||
         // Node.js 0.10 has enumerable non-index properties on buffers.
         (isBuff && (key == 'offset' || key == 'parent')) ||
         // PhantomJS 2 has enumerable non-index properties on typed arrays.
         (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
         // Skip index properties.
         isIndex(key, length)
      ))) {
    result.push(key);
  }
}
return result;

}

module.exports = arrayLikeKeys;

/***/ }), /* 175 */ /***/ (function(module, exports, webpack_require) {

var baseIsArguments = webpack_require(229),

isObjectLike = __webpack_require__(12);

/** Used for built-in method references. */ var objectProto = Object.prototype;

/** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty;

/** Built-in value references. */ var propertyIsEnumerable = objectProto.propertyIsEnumerable;

/**

* Checks if `value` is likely an `arguments` object.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an `arguments` object,
*  else `false`.
* @example
*
* _.isArguments(function() { return arguments; }());
* // => true
*
* _.isArguments([1, 2, 3]);
* // => false
*/

var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {

return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
  !propertyIsEnumerable.call(value, 'callee');

};

module.exports = isArguments;

/***/ }), /* 176 */ /***/ (function(module, exports, webpack_require) {

/* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */ var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

module.exports = freeGlobal;

/* WEBPACK VAR INJECTION */}.call(exports, webpack_require(19)))

/***/ }), /* 177 */ /***/ (function(module, exports, webpack_require) {

/* WEBPACK VAR INJECTION */(function(module) {var root = webpack_require(5),

stubFalse = __webpack_require__(232);

/** 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;

/** Built-in value references. */ var Buffer = moduleExports ? root.Buffer : undefined;

/* Built-in method references for those with the same name as other `lodash` methods. */ var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;

/**

* Checks if `value` is a buffer.
*
* @static
* @memberOf _
* @since 4.3.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
* @example
*
* _.isBuffer(new Buffer(2));
* // => true
*
* _.isBuffer(new Uint8Array(2));
* // => false
*/

var isBuffer = nativeIsBuffer || stubFalse;

module.exports = isBuffer;

/* WEBPACK VAR INJECTION */}.call(exports, webpack_require(3)(module)))

/***/ }), /* 178 */ /***/ (function(module, exports, webpack_require) {

var baseIsTypedArray = webpack_require(233),

baseUnary = __webpack_require__(179),
nodeUtil = __webpack_require__(234);

/* Node.js helper references. */ var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;

/**

* Checks if `value` is classified as a typed array.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
* @example
*
* _.isTypedArray(new Uint8Array);
* // => true
*
* _.isTypedArray([]);
* // => false
*/

var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;

module.exports = isTypedArray;

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

/**

* The base implementation of `_.unary` without support for storing metadata.
*
* @private
* @param {Function} func The function to cap arguments for.
* @returns {Function} Returns the new capped function.
*/

function baseUnary(func) {

return function(value) {
  return func(value);
};

}

module.exports = baseUnary;

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

/** Used for built-in method references. */ var objectProto = Object.prototype;

/**

* Checks if `value` is likely a prototype object.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
*/

function isPrototype(value) {

var Ctor = value && value.constructor,
    proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;

return value === proto;

}

module.exports = isPrototype;

/***/ }), /* 181 */ /***/ (function(module, exports, webpack_require) {

var baseGetTag = webpack_require(11),

isObject = __webpack_require__(14);

/** `Object#toString` result references. */ var asyncTag = '[object AsyncFunction]',

funcTag = '[object Function]',
genTag = '[object GeneratorFunction]',
proxyTag = '[object Proxy]';

/**

* Checks if `value` is classified as a `Function` object.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a function, else `false`.
* @example
*
* _.isFunction(_);
* // => true
*
* _.isFunction(/abc/);
* // => false
*/

function isFunction(value) {

if (!isObject(value)) {
  return false;
}
// The use of `Object#toString` avoids issues with the `typeof` operator
// in Safari 9 which returns 'object' for typed arrays and other constructors.
var tag = baseGetTag(value);
return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;

}

module.exports = isFunction;

/***/ }), /* 182 */ /***/ (function(module, exports, webpack_require) {

var defineProperty = webpack_require(183);

/**

* The base implementation of `assignValue` and `assignMergeValue` without
* value checks.
*
* @private
* @param {Object} object The object to modify.
* @param {string} key The key of the property to assign.
* @param {*} value The value to assign.
*/

function baseAssignValue(object, key, value) {

if (key == '__proto__' && defineProperty) {
  defineProperty(object, key, {
    'configurable': true,
    'enumerable': true,
    'value': value,
    'writable': true
  });
} else {
  object[key] = value;
}

}

module.exports = baseAssignValue;

/***/ }), /* 183 */ /***/ (function(module, exports, webpack_require) {

var getNative = webpack_require(10);

var defineProperty = (function() {

try {
  var func = getNative(Object, 'defineProperty');
  func({}, '', {});
  return func;
} catch (e) {}

}());

module.exports = defineProperty;

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

/** Used for built-in method references. */ var funcProto = Function.prototype;

/** Used to resolve the decompiled source of functions. */ var funcToString = funcProto.toString;

/**

* Converts `func` to its source code.
*
* @private
* @param {Function} func The function to convert.
* @returns {string} Returns the source code.
*/

function toSource(func) {

if (func != null) {
  try {
    return funcToString.call(func);
  } catch (e) {}
  try {
    return (func + '');
  } catch (e) {}
}
return '';

}

module.exports = toSource;

/***/ }), /* 185 */ /***/ (function(module, exports, webpack_require) {

var ListCache = webpack_require(24),

stackClear = __webpack_require__(269),
stackDelete = __webpack_require__(270),
stackGet = __webpack_require__(271),
stackHas = __webpack_require__(272),
stackSet = __webpack_require__(273);

/**

* Creates a stack cache object to store key-value pairs.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/

function Stack(entries) {

var data = this.__data__ = new ListCache(entries);
this.size = data.size;

}

// Add methods to `Stack`. Stack.prototype.clear = stackClear; Stack.prototype = stackDelete; Stack.prototype.get = stackGet; Stack.prototype.has = stackHas; Stack.prototype.set = stackSet;

module.exports = Stack;

/***/ }), /* 186 */ /***/ (function(module, exports, webpack_require) {

var baseIsEqualDeep = webpack_require(286),

isObjectLike = __webpack_require__(12);

/**

* The base implementation of `_.isEqual` which supports partial comparisons
* and tracks traversed objects.
*
* @private
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @param {boolean} bitmask The bitmask flags.
*  1 - Unordered comparison
*  2 - Partial comparison
* @param {Function} [customizer] The function to customize comparisons.
* @param {Object} [stack] Tracks traversed `value` and `other` objects.
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
*/

function baseIsEqual(value, other, bitmask, customizer, stack) {

if (value === other) {
  return true;
}
if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
  return value !== value && other !== other;
}
return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);

}

module.exports = baseIsEqual;

/***/ }), /* 187 */ /***/ (function(module, exports, webpack_require) {

var SetCache = webpack_require(188),

arraySome = __webpack_require__(289),
cacheHas = __webpack_require__(189);

/** Used to compose bitmasks for value comparisons. */ var COMPARE_PARTIAL_FLAG = 1,

COMPARE_UNORDERED_FLAG = 2;

/**

* A specialized version of `baseIsEqualDeep` for arrays with support for
* partial deep comparisons.
*
* @private
* @param {Array} array The array to compare.
* @param {Array} other The other array to compare.
* @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
* @param {Function} customizer The function to customize comparisons.
* @param {Function} equalFunc The function to determine equivalents of values.
* @param {Object} stack Tracks traversed `array` and `other` objects.
* @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
*/

function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {

var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
    arrLength = array.length,
    othLength = other.length;

if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
  return false;
}
// Assume cyclic values are equal.
var stacked = stack.get(array);
if (stacked && stack.get(other)) {
  return stacked == other;
}
var index = -1,
    result = true,
    seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;

stack.set(array, other);
stack.set(other, array);

// Ignore non-index properties.
while (++index < arrLength) {
  var arrValue = array[index],
      othValue = other[index];

  if (customizer) {
    var compared = isPartial
      ? customizer(othValue, arrValue, index, other, array, stack)
      : customizer(arrValue, othValue, index, array, other, stack);
  }
  if (compared !== undefined) {
    if (compared) {
      continue;
    }
    result = false;
    break;
  }
  // Recursively compare arrays (susceptible to call stack limits).
  if (seen) {
    if (!arraySome(other, function(othValue, othIndex) {
          if (!cacheHas(seen, othIndex) &&
              (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
            return seen.push(othIndex);
          }
        })) {
      result = false;
      break;
    }
  } else if (!(
        arrValue === othValue ||
          equalFunc(arrValue, othValue, bitmask, customizer, stack)
      )) {
    result = false;
    break;
  }
}
stack['delete'](array);
stack['delete'](other);
return result;

}

module.exports = equalArrays;

/***/ }), /* 188 */ /***/ (function(module, exports, webpack_require) {

var MapCache = webpack_require(35),

setCacheAdd = __webpack_require__(287),
setCacheHas = __webpack_require__(288);

/**

*
* Creates an array cache object to store unique values.
*
* @private
* @constructor
* @param {Array} [values] The values to cache.
*/

function SetCache(values) {

var index = -1,
    length = values == null ? 0 : values.length;

this.__data__ = new MapCache;
while (++index < length) {
  this.add(values[index]);
}

}

// Add methods to `SetCache`. SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; SetCache.prototype.has = setCacheHas;

module.exports = SetCache;

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

/**

* Checks if a `cache` value for `key` exists.
*
* @private
* @param {Object} cache The cache to query.
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/

function cacheHas(cache, key) {

return cache.has(key);

}

module.exports = cacheHas;

/***/ }), /* 190 */ /***/ (function(module, exports, webpack_require) {

var getNative = webpack_require(10),

root = __webpack_require__(5);

/* Built-in method references that are verified to be native. */ var Set = getNative(root, 'Set');

module.exports = Set;

/***/ }), /* 191 */ /***/ (function(module, exports, webpack_require) {

var isObject = webpack_require(14);

/**

* Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` if suitable for strict
*  equality comparisons, else `false`.
*/

function isStrictComparable(value) {

return value === value && !isObject(value);

}

module.exports = isStrictComparable;

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

/**

* A specialized version of `matchesProperty` for source values suitable
* for strict equality comparisons, i.e. `===`.
*
* @private
* @param {string} key The key of the property to get.
* @param {*} srcValue The value to match.
* @returns {Function} Returns the new spec function.
*/

function matchesStrictComparable(key, srcValue) {

return function(object) {
  if (object == null) {
    return false;
  }
  return object[key] === srcValue &&
    (srcValue !== undefined || (key in Object(object)));
};

}

module.exports = matchesStrictComparable;

/***/ }), /* 193 */ /***/ (function(module, exports, webpack_require) {

var castPath = webpack_require(194),

toKey = __webpack_require__(28);

/**

* The base implementation of `_.get` without support for default values.
*
* @private
* @param {Object} object The object to query.
* @param {Array|string} path The path of the property to get.
* @returns {*} Returns the resolved value.
*/

function baseGet(object, path) {

path = castPath(path, object);

var index = 0,
    length = path.length;

while (object != null && index < length) {
  object = object[toKey(path[index++])];
}
return (index && index == length) ? object : undefined;

}

module.exports = baseGet;

/***/ }), /* 194 */ /***/ (function(module, exports, webpack_require) {

var isArray = webpack_require(2),

isKey = __webpack_require__(37),
stringToPath = __webpack_require__(307),
toString = __webpack_require__(310);

/**

* Casts `value` to a path array if it's not one.
*
* @private
* @param {*} value The value to inspect.
* @param {Object} [object] The object to query keys on.
* @returns {Array} Returns the cast property path array.
*/

function castPath(value, object) {

if (isArray(value)) {
  return value;
}
return isKey(value, object) ? [value] : stringToPath(toString(value));

}

module.exports = castPath;

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

/**

* The base implementation of `_.findIndex` and `_.findLastIndex` without
* support for iteratee shorthands.
*
* @private
* @param {Array} array The array to inspect.
* @param {Function} predicate The function invoked per iteration.
* @param {number} fromIndex The index to search from.
* @param {boolean} [fromRight] Specify iterating from right to left.
* @returns {number} Returns the index of the matched value, else `-1`.
*/

function baseFindIndex(array, predicate, fromIndex, fromRight) {

var length = array.length,
    index = fromIndex + (fromRight ? 1 : -1);

while ((fromRight ? index-- : ++index < length)) {
  if (predicate(array[index], index, array)) {
    return index;
  }
}
return -1;

}

module.exports = baseFindIndex;

/***/ }), /* 196 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.getHead = exports.getDirection = exports.getCurrentBranch = exports.getCommitsArray = exports.getCommits = exports.getBranches = exports.getBranchesAsObjArray = exports.clear = exports.prettyPrint = exports.reset = exports.checkout = exports.merge = exports.branch = exports.commit = exports.getOptions = exports.setOptions = exports.setDirection = undefined;

var _orderBy2 = webpack_require(323);

var _orderBy3 = _interopRequireDefault(_orderBy2);

var _map2 = webpack_require(328);

var _map3 = _interopRequireDefault(_map2);

var _uniqBy2 = webpack_require(329);

var _uniqBy3 = _interopRequireDefault(_uniqBy2);

var _each2 = webpack_require(172);

var _each3 = _interopRequireDefault(_each2);

var _maxBy2 = webpack_require(338);

var _maxBy3 = _interopRequireDefault(_maxBy2);

var _logger = webpack_require(1);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var commits = {}; var head = null; var branches = { 'master': head }; var curBranch = 'master'; var direction = 'LR'; var seq = 0;

function getRandomInt(min, max) {

return Math.floor(Math.random() * (max - min)) + min;

}

function getId() {

var pool = '0123456789abcdef';
var id = '';
for (var i = 0; i < 7; i++) {
  id += pool[getRandomInt(0, 16)];
}
return id;

}

function isfastforwardable(currentCommit, otherCommit) {

_logger.logger.debug('Entering isfastforwardable:', currentCommit.id, otherCommit.id);
while (currentCommit.seq <= otherCommit.seq && currentCommit !== otherCommit) {
  // only if other branch has more commits
  if (otherCommit.parent == null) break;
  if (Array.isArray(otherCommit.parent)) {
    _logger.logger.debug('In merge commit:', otherCommit.parent);
    return isfastforwardable(currentCommit, commits[otherCommit.parent[0]]) || isfastforwardable(currentCommit, commits[otherCommit.parent[1]]);
  } else {
    otherCommit = commits[otherCommit.parent];
  }
}
_logger.logger.debug(currentCommit.id, otherCommit.id);
return currentCommit.id === otherCommit.id;

}

function isReachableFrom(currentCommit, otherCommit) {

var currentSeq = currentCommit.seq;
var otherSeq = otherCommit.seq;
if (currentSeq > otherSeq) return isfastforwardable(otherCommit, currentCommit);
return false;

}

var setDirection = exports.setDirection = function setDirection(dir) {

direction = dir;

}; var options = {}; var setOptions = exports.setOptions = function setOptions(rawOptString) {

_logger.logger.debug('options str', rawOptString);
rawOptString = rawOptString && rawOptString.trim();
rawOptString = rawOptString || '{}';
try {
  options = JSON.parse(rawOptString);
} catch (e) {
  _logger.logger.error('error while parsing gitGraph options', e.message);
}

};

var getOptions = exports.getOptions = function getOptions() {

return options;

};

var commit = exports.commit = function commit(msg) {

var commit = {
  id: getId(),
  message: msg,
  seq: seq++,
  parent: head == null ? null : head.id
};
head = commit;
commits[commit.id] = commit;
branches[curBranch] = commit.id;
_logger.logger.debug('in pushCommit ' + commit.id);

};

var branch = exports.branch = function branch(name) {

branches[name] = head != null ? head.id : null;
_logger.logger.debug('in createBranch');

};

var merge = exports.merge = function merge(otherBranch) {

var currentCommit = commits[branches[curBranch]];
var otherCommit = commits[branches[otherBranch]];
if (isReachableFrom(currentCommit, otherCommit)) {
  _logger.logger.debug('Already merged');
  return;
}
if (isfastforwardable(currentCommit, otherCommit)) {
  branches[curBranch] = branches[otherBranch];
  head = commits[branches[curBranch]];
} else {
  // create merge commit
  var commit = {
    id: getId(),
    message: 'merged branch ' + otherBranch + ' into ' + curBranch,
    seq: seq++,
    parent: [head == null ? null : head.id, branches[otherBranch]]
  };
  head = commit;
  commits[commit.id] = commit;
  branches[curBranch] = commit.id;
}
_logger.logger.debug(branches);
_logger.logger.debug('in mergeBranch');

};

var checkout = exports.checkout = function checkout(branch) {

_logger.logger.debug('in checkout');
curBranch = branch;
var id = branches[curBranch];
head = commits[id];

};

var reset = exports.reset = function reset(commitRef) {

_logger.logger.debug('in reset', commitRef);
var ref = commitRef.split(':')[0];
var parentCount = parseInt(commitRef.split(':')[1]);
var commit = ref === 'HEAD' ? head : commits[branches[ref]];
_logger.logger.debug(commit, parentCount);
while (parentCount > 0) {
  commit = commits[commit.parent];
  parentCount--;
  if (!commit) {
    var err = 'Critical error - unique parent commit not found during reset';
    _logger.logger.error(err);
    throw err;
  }
}
head = commit;
branches[curBranch] = commit.id;

};

function upsert(arr, key, newval) {

var index = arr.indexOf(key);
if (index === -1) {
  arr.push(newval);
} else {
  arr.splice(index, 1, newval);
}

}

function prettyPrintCommitHistory(commitArr) {

var commit = (0, _maxBy3.default)(commitArr, 'seq');
var line = '';
commitArr.forEach(function (c) {
  if (c === commit) {
    line += '\t*';
  } else {
    line += '\t|';
  }
});
var label = [line, commit.id, commit.seq];
(0, _each3.default)(branches, function (value, key) {
  if (value === commit.id) label.push(key);
});
_logger.logger.debug(label.join(' '));
if (Array.isArray(commit.parent)) {
  var newCommit = commits[commit.parent[0]];
  upsert(commitArr, commit, newCommit);
  commitArr.push(commits[commit.parent[1]]);
} else if (commit.parent == null) {
  return;
} else {
  var nextCommit = commits[commit.parent];
  upsert(commitArr, commit, nextCommit);
}
commitArr = (0, _uniqBy3.default)(commitArr, 'id');
prettyPrintCommitHistory(commitArr);

}

var prettyPrint = exports.prettyPrint = function prettyPrint() {

_logger.logger.debug(commits);
var node = getCommitsArray()[0];
prettyPrintCommitHistory([node]);

};

var clear = exports.clear = function clear() {

commits = {};
head = null;
branches = { 'master': head };
curBranch = 'master';
seq = 0;

};

var getBranchesAsObjArray = exports.getBranchesAsObjArray = function getBranchesAsObjArray() {

var branchArr = (0, _map3.default)(branches, function (value, key) {
  return { 'name': key, 'commit': commits[value] };
});
return branchArr;

};

var getBranches = exports.getBranches = function getBranches() {

return branches;

}; var getCommits = exports.getCommits = function getCommits() {

return commits;

}; var getCommitsArray = exports.getCommitsArray = function getCommitsArray() {

var commitArr = Object.keys(commits).map(function (key) {
  return commits[key];
});
commitArr.forEach(function (o) {
  _logger.logger.debug(o.id);
});
return (0, _orderBy3.default)(commitArr, ['seq'], ['desc']);

}; var getCurrentBranch = exports.getCurrentBranch = function getCurrentBranch() {

return curBranch;

}; var getDirection = exports.getDirection = function getDirection() {

return direction;

}; var getHead = exports.getHead = function getHead() {

return head;

};

exports.default = {

setDirection: setDirection,
setOptions: setOptions,
getOptions: getOptions,
commit: commit,
branch: branch,
merge: merge,
checkout: checkout,
reset: reset,
prettyPrint: prettyPrint,
clear: clear,
getBranchesAsObjArray: getBranchesAsObjArray,
getBranches: getBranches,
getCommits: getCommits,
getCommitsArray: getCommitsArray,
getCurrentBranch: getCurrentBranch,
getDirection: getDirection,
getHead: getHead

};

/***/ }), /* 197 */ /***/ (function(module, exports, webpack_require) {

var baseEach = webpack_require(173),

isArrayLike = __webpack_require__(13);

/**

* The base implementation of `_.map` without support for iteratee shorthands.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array} Returns the new mapped array.
*/

function baseMap(collection, iteratee) {

var index = -1,
    result = isArrayLike(collection) ? Array(collection.length) : [];

baseEach(collection, function(value, key, collection) {
  result[++index] = iteratee(value, key, collection);
});
return result;

}

module.exports = baseMap;

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

module.exports = {“name”:“mermaid”,“version”:“7.0.14”,“description”:“Markdownish syntax for generating flowcharts, sequence diagrams, class diagrams, gantt charts and git graphs.”,“main”:“dist/mermaid.core.js”,“keywords”:[“diagram”,“markdown”,“flowchart”,“sequence diagram”,“gantt”,“class diagram”,“git graph”],“bin”:{“mermaid”:“./bin/mermaid.js”},“scripts”:{“build”:“node -r babel-register ./node_modules/.bin/webpack –progress –colors”,“build:watch”:“yarn build –watch”,“release”:“yarn build -p –config webpack.config.prod.js”,“upgrade”:“yarn upgrade –latest && yarn remove d3 && yarn add d3@3.5.17”,“lint”:“standard”,“karma”:“node -r babel-register node_modules/.bin/karma start karma.conf.js –single-run”,“jest”:“jest –coverage –runInBand”,“test”:“yarn lint && yarn karma”,“jison”:“node -r babel-register node_modules/.bin/gulp jison”,“prepublishOnly”:“yarn build && yarn release && yarn test”},“repository”:{“type”:“git”,“url”:“github.com/knsv/mermaid”},“author”:“Knut Sveidqvist”,“license”:“MIT”,“standard”:{“ignore”:[“*/parser/.js”,“dist/*/.js”]},“dependencies”:{“chalk”:“^2.1.0”,“d3”:“3.5.17”,“dagre-d3-renderer”:“^0.4.23”,“dagre-layout”:“^0.8.0”,“he”:“^1.1.1”,“lodash”:“^4.17.4”,“minimist”:“^1.2.0”,“mkdirp”:“^0.5.1”,“moment”:“^2.18.1”,“semver”:“^5.4.1”,“which”:“^1.3.0”},“devDependencies”:{“async”:“^2.5.0”,“babel-core”:“^6.26.0”,“babel-loader”:“^7.1.2”,“babel-plugin-lodash”:“^3.2.11”,“babel-preset-env”:“^1.6.0”,“babel-preset-es2015”:“^6.24.1”,“clone”:“^2.1.1”,“codeclimate-test-reporter”:“^0.5.0”,“css-loader”:“^0.28.7”,“extract-text-webpack-plugin”:“^3.0.0”,“gulp”:“^3.9.1”,“gulp-filelog”:“^0.4.1”,“gulp-jison”:“^1.2.0”,“inject-loader”:“^3.0.1”,“jasmine”:“^2.8.0”,“jasmine-es6”:“^0.4.1”,“jest”:“^21.0.2”,“jison”:“^0.4.18”,“karma”:“^1.7.1”,“karma-chrome-launcher”:“^2.2.0”,“karma-jasmine”:“^1.1.0”,“karma-webpack”:“^2.0.4”,“less”:“^2.7.2”,“less-loader”:“^4.0.5”,“phantomjs-prebuilt”:“^2.1.15”,“rimraf”:“^2.6.1”,“standard”:“^10.0.3”,“style-loader”:“^0.18.2”,“webpack”:“^3.5.6”,“webpack-node-externals”:“^1.6.0”},“files”:,“jest”:{“testRegex”:“test/cli_test-.+?\.js”}}

/***/ }), /* 199 */ /***/ (function(module, exports, webpack_require) {

“use strict”; /* WEBPACK VAR INJECTION */(function(global) {

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _he = webpack_require(200);

var _he2 = _interopRequireDefault(_he);

var _mermaidAPI = webpack_require(201);

var _mermaidAPI2 = _interopRequireDefault(_mermaidAPI);

var _logger = webpack_require(1);

var _package = webpack_require(198);

var _package2 = _interopRequireDefault(_package);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**

* Web page integration module for the mermaid framework. It uses the mermaidAPI for mermaid functionality and to render
* the diagrams to svg code.
*/

var nextId = 0;

/**

* ## init
* Function that goes through the document to find the chart definitions in there and render them.
*
* The function tags the processed attributes with the attribute data-processed and ignores found elements with the
* attribute already set. This way the init function can be triggered several times.
*
* Optionally, `init` can accept in the second argument one of the following:
* - a DOM Node
* - an array of DOM nodes (as would come from a jQuery selector)
* - a W3C selector, a la `.mermaid`
*
* ```mermaid
* graph LR;
*  a(Find elements)-->b{Processed}
*  b-->|Yes|c(Leave element)
*  b-->|No |d(Transform)
* ```
* Renders the mermaid diagrams
* @param nodes a css selector or an array of nodes
*/

var init = function init() {

var conf = _mermaidAPI2.default.getConfig();
_logger.logger.debug('Starting rendering diagrams');
var nodes;
if (arguments.length >= 2) {
  /*! sequence config was passed as #1 */
  if (typeof arguments[0] !== 'undefined') {
    mermaid.sequenceConfig = arguments[0];
  }

  nodes = arguments[1];
} else {
  nodes = arguments[0];
}

// if last argument is a function this is the callback function
var callback;
if (typeof arguments[arguments.length - 1] === 'function') {
  callback = arguments[arguments.length - 1];
  _logger.logger.debug('Callback function found');
} else {
  if (typeof conf.mermaid !== 'undefined') {
    if (typeof conf.mermaid.callback === 'function') {
      callback = conf.mermaid.callback;
      _logger.logger.debug('Callback function found');
    } else {
      _logger.logger.debug('No Callback function found');
    }
  }
}
nodes = nodes === undefined ? document.querySelectorAll('.mermaid') : typeof nodes === 'string' ? document.querySelectorAll(nodes) : nodes instanceof window.Node ? [nodes] : nodes; // Last case  - sequence config was passed pick next

if (typeof global.mermaid_config !== 'undefined') {
  _mermaidAPI2.default.initialize(global.mermaid_config);
}
_logger.logger.debug('Start On Load before: ' + mermaid.startOnLoad);
if (typeof mermaid.startOnLoad !== 'undefined') {
  _logger.logger.debug('Start On Load inner: ' + mermaid.startOnLoad);
  _mermaidAPI2.default.initialize({ startOnLoad: mermaid.startOnLoad });
}

if (typeof mermaid.ganttConfig !== 'undefined') {
  _mermaidAPI2.default.initialize({ gantt: mermaid.ganttConfig });
}

var txt;
var insertSvg = function insertSvg(svgCode, bindFunctions) {
  element.innerHTML = svgCode;
  if (typeof callback !== 'undefined') {
    callback(id);
  }
  bindFunctions(element);
};

for (var i = 0; i < nodes.length; i++) {
  var element = nodes[i];

  /*! Check if previously processed */
  if (!element.getAttribute('data-processed')) {
    element.setAttribute('data-processed', true);
  } else {
    continue;
  }

  var id = 'mermaidChart' + nextId++;

  // Fetch the graph definition including tags
  txt = element.innerHTML;

  // transforms the html to pure text
  txt = _he2.default.decode(txt).trim();

  _mermaidAPI2.default.render(id, txt, insertSvg, element);
}

};

var version = function version() {

return 'v' + _package2.default.version;

};

var initialize = function initialize(config) {

_logger.logger.debug('Initializing mermaid');
if (typeof config.mermaid !== 'undefined') {
  if (typeof config.mermaid.startOnLoad !== 'undefined') {
    mermaid.startOnLoad = config.mermaid.startOnLoad;
  }
  if (typeof config.mermaid.htmlLabels !== 'undefined') {
    mermaid.htmlLabels = config.mermaid.htmlLabels;
  }
}
_mermaidAPI2.default.initialize(config);

};

/**

* ##contentLoaded
* Callback function that is called when page is loaded. This functions fetches configuration for mermaid rendering and
* calls init for rendering the mermaid diagrams on the page.
*/

var contentLoaded = function contentLoaded() {

var config;
// Check state of start config mermaid namespace
if (typeof global.mermaid_config !== 'undefined') {
  if (global.mermaid_config.htmlLabels === false) {
    mermaid.htmlLabels = false;
  }
}

if (mermaid.startOnLoad) {
  // For backwards compatability reasons also check mermaid_config variable
  if (typeof global.mermaid_config !== 'undefined') {
    // Check if property startOnLoad is set
    if (global.mermaid_config.startOnLoad === true) {
      mermaid.init();
    }
  } else {
    // No config found, do check API config
    config = _mermaidAPI2.default.getConfig();
    if (config.startOnLoad) {
      mermaid.init();
    }
  }
} else {
  if (typeof mermaid.startOnLoad === 'undefined') {
    _logger.logger.debug('In start, no config');
    config = _mermaidAPI2.default.getConfig();
    if (config.startOnLoad) {
      mermaid.init();
    }
  }
}

};

if (typeof document !== 'undefined') {

/*!
 * Wait for document loaded before starting the execution
 */
window.addEventListener('load', function () {
  contentLoaded();
}, false);

}

var mermaid = {

startOnLoad: true,
htmlLabels: true,

mermaidAPI: _mermaidAPI2.default,
parse: _mermaidAPI2.default.parse,
render: _mermaidAPI2.default.render,

init: init,
initialize: initialize,
version: version,

contentLoaded: contentLoaded

};

exports.default = mermaid; /* WEBPACK VAR INJECTION */}.call(exports, webpack_require(19)))

/***/ }), /* 200 */ /***/ (function(module, exports, webpack_require) {

/* WEBPACK VAR INJECTION */(function(module, global) {var WEBPACK_AMD_DEFINE_RESULT;/*! mths.be/he v1.1.1 by @mathias | MIT license */ ;(function(root) {

// Detect free variables `exports`.
var freeExports = typeof exports == 'object' && exports;

// Detect free variable `module`.
var freeModule = typeof module == 'object' && module &&
        module.exports == freeExports && module;

// Detect free variable `global`, from Node.js or Browserified code,
// and use it as `root`.
var freeGlobal = typeof global == 'object' && global;
if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
        root = freeGlobal;
}

/*--------------------------------------------------------------------------*/

// All astral symbols.
var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
// All ASCII symbols (not just printable ASCII) except those listed in the
// first column of the overrides table.
// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
var regexAsciiWhitelist = /[\x01-\x7F]/g;
// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
// code points listed in the first column of the overrides table on
// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;

var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};

var regexEscape = /["&'<>`]/g;
var escapeMap = {
        '"': '&quot;',
        '&': '&amp;',
        '\'': '&#x27;',
        '<': '&lt;',
        // See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
        // following is not strictly necessary unless it’s part of a tag or an
        // unquoted attribute value. We’re only escaping it to support those
        // situations, and for XML support.
        '>': '&gt;',
        // In Internet Explorer ≤ 8, the backtick character can be used
        // to break out of (un)quoted attribute values or HTML comments.
        // See http://html5sec.org/#102, http://html5sec.org/#108, and
        // http://html5sec.org/#133.
        '`': '&#x60;'
};

var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
var regexDecode = /&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)([=a-zA-Z0-9])?/g;
var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];

/*--------------------------------------------------------------------------*/

var stringFromCharCode = String.fromCharCode;

var object = {};
var hasOwnProperty = object.hasOwnProperty;
var has = function(object, propertyName) {
        return hasOwnProperty.call(object, propertyName);
};

var contains = function(array, value) {
        var index = -1;
        var length = array.length;
        while (++index < length) {
                if (array[index] == value) {
                        return true;
                }
        }
        return false;
};

var merge = function(options, defaults) {
        if (!options) {
                return defaults;
        }
        var result = {};
        var key;
        for (key in defaults) {
                // A `hasOwnProperty` check is not needed here, since only recognized
                // option names are used anyway. Any others are ignored.
                result[key] = has(options, key) ? options[key] : defaults[key];
        }
        return result;
};

// Modified version of `ucs2encode`; see https://mths.be/punycode.
var codePointToSymbol = function(codePoint, strict) {
        var output = '';
        if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
                // See issue #4:
                // “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
                // greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
                // REPLACEMENT CHARACTER.”
                if (strict) {
                        parseError('character reference outside the permissible Unicode range');
                }
                return '\uFFFD';
        }
        if (has(decodeMapNumeric, codePoint)) {
                if (strict) {
                        parseError('disallowed character reference');
                }
                return decodeMapNumeric[codePoint];
        }
        if (strict && contains(invalidReferenceCodePoints, codePoint)) {
                parseError('disallowed character reference');
        }
        if (codePoint > 0xFFFF) {
                codePoint -= 0x10000;
                output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
                codePoint = 0xDC00 | codePoint & 0x3FF;
        }
        output += stringFromCharCode(codePoint);
        return output;
};

var hexEscape = function(codePoint) {
        return '&#x' + codePoint.toString(16).toUpperCase() + ';';
};

var decEscape = function(codePoint) {
        return '&#' + codePoint + ';';
};

var parseError = function(message) {
        throw Error('Parse error: ' + message);
};

/*--------------------------------------------------------------------------*/

var encode = function(string, options) {
        options = merge(options, encode.options);
        var strict = options.strict;
        if (strict && regexInvalidRawCodePoint.test(string)) {
                parseError('forbidden code point');
        }
        var encodeEverything = options.encodeEverything;
        var useNamedReferences = options.useNamedReferences;
        var allowUnsafeSymbols = options.allowUnsafeSymbols;
        var escapeCodePoint = options.decimal ? decEscape : hexEscape;

        var escapeBmpSymbol = function(symbol) {
                return escapeCodePoint(symbol.charCodeAt(0));
        };

        if (encodeEverything) {
                // Encode ASCII symbols.
                string = string.replace(regexAsciiWhitelist, function(symbol) {
                        // Use named references if requested & possible.
                        if (useNamedReferences && has(encodeMap, symbol)) {
                                return '&' + encodeMap[symbol] + ';';
                        }
                        return escapeBmpSymbol(symbol);
                });
                // Shorten a few escapes that represent two symbols, of which at least one
                // is within the ASCII range.
                if (useNamedReferences) {
                        string = string
                                .replace(/&gt;\u20D2/g, '&nvgt;')
                                .replace(/&lt;\u20D2/g, '&nvlt;')
                                .replace(/&#x66;&#x6A;/g, '&fjlig;');
                }
                // Encode non-ASCII symbols.
                if (useNamedReferences) {
                        // Encode non-ASCII symbols that can be replaced with a named reference.
                        string = string.replace(regexEncodeNonAscii, function(string) {
                                // Note: there is no need to check `has(encodeMap, string)` here.
                                return '&' + encodeMap[string] + ';';
                        });
                }
                // Note: any remaining non-ASCII symbols are handled outside of the `if`.
        } else if (useNamedReferences) {
                // Apply named character references.
                // Encode `<>"'&` using named character references.
                if (!allowUnsafeSymbols) {
                        string = string.replace(regexEscape, function(string) {
                                return '&' + encodeMap[string] + ';'; // no need to check `has()` here
                        });
                }
                // Shorten escapes that represent two symbols, of which at least one is
                // `<>"'&`.
                string = string
                        .replace(/&gt;\u20D2/g, '&nvgt;')
                        .replace(/&lt;\u20D2/g, '&nvlt;');
                // Encode non-ASCII symbols that can be replaced with a named reference.
                string = string.replace(regexEncodeNonAscii, function(string) {
                        // Note: there is no need to check `has(encodeMap, string)` here.
                        return '&' + encodeMap[string] + ';';
                });
        } else if (!allowUnsafeSymbols) {
                // Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
                // using named character references.
                string = string.replace(regexEscape, escapeBmpSymbol);
        }
        return string
                // Encode astral symbols.
                .replace(regexAstralSymbols, function($0) {
                        // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
                        var high = $0.charCodeAt(0);
                        var low = $0.charCodeAt(1);
                        var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
                        return escapeCodePoint(codePoint);
                })
                // Encode any remaining BMP symbols that are not printable ASCII symbols
                // using a hexadecimal escape.
                .replace(regexBmpWhitelist, escapeBmpSymbol);
};
// Expose default options (so they can be overridden globally).
encode.options = {
        'allowUnsafeSymbols': false,
        'encodeEverything': false,
        'strict': false,
        'useNamedReferences': false,
        'decimal' : false
};

var decode = function(html, options) {
        options = merge(options, decode.options);
        var strict = options.strict;
        if (strict && regexInvalidEntity.test(html)) {
                parseError('malformed character reference');
        }
        return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7) {
                var codePoint;
                var semicolon;
                var decDigits;
                var hexDigits;
                var reference;
                var next;
                if ($1) {
                        // Decode decimal escapes, e.g. `&#119558;`.
                        decDigits = $1;
                        semicolon = $2;
                        if (strict && !semicolon) {
                                parseError('character reference was not terminated by a semicolon');
                        }
                        codePoint = parseInt(decDigits, 10);
                        return codePointToSymbol(codePoint, strict);
                }
                if ($3) {
                        // Decode hexadecimal escapes, e.g. `&#x1D306;`.
                        hexDigits = $3;
                        semicolon = $4;
                        if (strict && !semicolon) {
                                parseError('character reference was not terminated by a semicolon');
                        }
                        codePoint = parseInt(hexDigits, 16);
                        return codePointToSymbol(codePoint, strict);
                }
                if ($5) {
                        // Decode named character references with trailing `;`, e.g. `&copy;`.
                        reference = $5;
                        if (has(decodeMap, reference)) {
                                return decodeMap[reference];
                        } else {
                                // Ambiguous ampersand. https://mths.be/notes/ambiguous-ampersands
                                if (strict) {
                                        parseError(
                                                'named character reference was not terminated by a semicolon'
                                        );
                                }
                                return $0;
                        }
                }
                // If we’re still here, it’s a legacy reference for sure. No need for an
                // extra `if` check.
                // Decode named character references without trailing `;`, e.g. `&amp`
                // This is only a parse error if it gets converted to `&`, or if it is
                // followed by `=` in an attribute context.
                reference = $6;
                next = $7;
                if (next && options.isAttributeValue) {
                        if (strict && next == '=') {
                                parseError('`&` did not start a character reference');
                        }
                        return $0;
                } else {
                        if (strict) {
                                parseError(
                                        'named character reference was not terminated by a semicolon'
                                );
                        }
                        // Note: there is no need to check `has(decodeMapLegacy, reference)`.
                        return decodeMapLegacy[reference] + (next || '');
                }
        });
};
// Expose default options (so they can be overridden globally).
decode.options = {
        'isAttributeValue': false,
        'strict': false
};

var escape = function(string) {
        return string.replace(regexEscape, function($0) {
                // Note: there is no need to check `has(escapeMap, $0)` here.
                return escapeMap[$0];
        });
};

/*--------------------------------------------------------------------------*/

var he = {
        'version': '1.1.1',
        'encode': encode,
        'decode': decode,
        'escape': escape,
        'unescape': decode
};

// Some AMD build optimizers, like r.js, check for specific condition patterns
// like the following:
if (
        true
) {
        !(__WEBPACK_AMD_DEFINE_RESULT__ = function() {
                return he;
        }.call(exports, __webpack_require__, exports, module),
                        __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
}       else if (freeExports && !freeExports.nodeType) {
        if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
                freeModule.exports = he;
        } else { // in Narwhal or RingoJS v0.7.0-
                for (var key in he) {
                        has(he, key) && (freeExports[key] = he[key]);
                }
        }
} else { // in Rhino or a web browser
        root.he = he;
}

}(this));

/* WEBPACK VAR INJECTION */}.call(exports, webpack_require(3)(module), webpack_require(19)))

/***/ }), /* 201 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.decodeEntities = exports.encodeEntities = exports.version = undefined;

var _typeof = typeof Symbol === “function” && typeof Symbol.iterator === “symbol” ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === “function” && obj.constructor === Symbol && obj !== Symbol.prototype ? “symbol” : typeof obj; }; /**

 * ---
 * title: mermaidAPI
 * order: 5
 * ---
 * # mermaidAPI
 * This is the api to be used when handling the integration with the web page instead of using the default integration
 * (mermaid.js).
 *
 * The core of this api is the **render** function that given a graph definitionas text renders the graph/diagram and
 * returns a svg element for the graph. It is is then up to the user of the API to make use of the svg, either insert it
 * somewhere in the page or something completely different.
*/

var _logger = webpack_require(1);

var _graphDb = webpack_require(154);

var _graphDb2 = _interopRequireDefault(_graphDb);

var _utils = webpack_require(155);

var _utils2 = _interopRequireDefault(_utils);

var _flowRenderer = webpack_require(203);

var _flowRenderer2 = _interopRequireDefault(_flowRenderer);

var _sequenceRenderer = webpack_require(217);

var _sequenceRenderer2 = _interopRequireDefault(_sequenceRenderer);

var _exampleRenderer = webpack_require(219);

var _exampleRenderer2 = _interopRequireDefault(_exampleRenderer);

var _example = webpack_require(166);

var _example2 = _interopRequireDefault(_example);

var _flow = webpack_require(156);

var _flow2 = _interopRequireDefault(_flow);

var _dot = webpack_require(157);

var _dot2 = _interopRequireDefault(_dot);

var _sequenceDiagram = webpack_require(163);

var _sequenceDiagram2 = _interopRequireDefault(_sequenceDiagram);

var _sequenceDb = webpack_require(164);

var _sequenceDb2 = _interopRequireDefault(_sequenceDb);

var _exampleDb = webpack_require(165);

var _exampleDb2 = _interopRequireDefault(_exampleDb);

var _ganttRenderer = webpack_require(220);

var _ganttRenderer2 = _interopRequireDefault(_ganttRenderer);

var _gantt = webpack_require(167);

var _gantt2 = _interopRequireDefault(_gantt);

var _ganttDb = webpack_require(168);

var _ganttDb2 = _interopRequireDefault(_ganttDb);

var _classDiagram = webpack_require(169);

var _classDiagram2 = _interopRequireDefault(_classDiagram);

var _classRenderer = webpack_require(221);

var _classRenderer2 = _interopRequireDefault(_classRenderer);

var _classDb = webpack_require(170);

var _classDb2 = _interopRequireDefault(_classDb);

var _gitGraph = webpack_require(171);

var _gitGraph2 = _interopRequireDefault(_gitGraph);

var _gitGraphRenderer = webpack_require(222);

var _gitGraphRenderer2 = _interopRequireDefault(_gitGraphRenderer);

var _gitGraphAst = webpack_require(196);

var _gitGraphAst2 = _interopRequireDefault(_gitGraphAst);

var _d = webpack_require(6);

var _d2 = _interopRequireDefault(_d);

var _package = webpack_require(198);

var _package2 = _interopRequireDefault(_package);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**

* ## Configuration
* These are the default options which can be overridden with the initialization call as in the example below:
* ```
* mermaid.initialize({
*   flowchart:{
*      htmlLabels: false
*   }
* });
* ```
*/

var config = {

/**
 * logLevel , decides the amount of logging to be used.
 *    * debug: 1
 *    * info: 2
 *    * warn: 3
 *    * error: 4
 *    * fatal: 5
 */
logLevel: 5,
/**
 * **cloneCssStyles** - This options controls whether or not the css rules should be copied into the generated svg
 */
cloneCssStyles: true,

/**
 * **startOnLoad** - This options controls whether or mermaid starts when the page loads
 */
startOnLoad: true,

/**
 * **arrowMarkerAbsolute** - This options controls whether or arrow markers in html code will be absolute paths or
 * an anchor, #. This matters if you are using base tag settings.
 */
arrowMarkerAbsolute: false,

/**
 * ### flowchart
 * *The object containing configurations specific for flowcharts*
 */
flowchart: {
  /**
   * **htmlLabels** - Flag for setting whether or not a html tag should be used for rendering labels
   * on the edges
   */
  htmlLabels: true,
  /**
   * **useMaxWidth** - Flag for setting whether or not a all available width should be used for
   * the diagram.
   */
  useMaxWidth: true
},

/**
 * ###  sequenceDiagram
 * The object containing configurations specific for sequence diagrams
 */
sequenceDiagram: {

  /**
   * **diagramMarginX** - margin to the right and left of the sequence diagram
   */
  diagramMarginX: 50,

  /**
   * **diagramMarginY** - margin to the over and under the sequence diagram
   */
  diagramMarginY: 10,

  /**
   * **actorMargin** - Margin between actors
   */
  actorMargin: 50,

  /**
   * **width** - Width of actor boxes
   */
  width: 150,

  /**
   * **height** - Height of actor boxes
   */
  height: 65,

  /**
   * **boxMargin** - Margin around loop boxes
   */
  boxMargin: 10,

  /**
   * **boxTextMargin** - margin around the text in loop/alt/opt boxes
   */
  boxTextMargin: 5,

  /**
   * **noteMargin** - margin around notes
   */
  noteMargin: 10,

  /**
   * **messageMargin** - Space between messages
   */
  messageMargin: 35,

  /**
   * **mirrorActors** - mirror actors under diagram
   */
  mirrorActors: true,

  /**
   * **bottomMarginAdj** - Depending on css styling this might need adjustment.
   * Prolongs the edge of the diagram downwards
   */
  bottomMarginAdj: 1,

  /**
   * **useMaxWidth** - when this flag is set the height and width is set to 100% and is then scaling with the
   * available space if not the absolute space required is used
   */
  useMaxWidth: true
},

/** ### gantt
 * The object containing configurations specific for gantt diagrams*
 */
gantt: {
  /**
   * **titleTopMargin** - margin top for the text over the gantt diagram
   */
  titleTopMargin: 25,

  /**
   * **barHeight** - the height of the bars in the graph
   */
  barHeight: 20,

  /**
   * **barGap** - the margin between the different activities in the gantt diagram
   */
  barGap: 4,

  /**
   *  **topPadding** - margin between title and gantt diagram and between axis and gantt diagram.
   */
  topPadding: 50,

  /**
   *  **leftPadding** - the space allocated for the section name to the left of the activities.
   */
  leftPadding: 75,

  /**
   *  **gridLineStartPadding** - Vertical starting position of the grid lines
   */
  gridLineStartPadding: 35,

  /**
   *  **fontSize** - font size ...
   */
  fontSize: 11,

  /**
   * **fontFamily** - font family ...
   */
  fontFamily: '"Open-Sans", "sans-serif"',

  /**
   * **numberSectionStyles** - the number of alternating section styles
   */
  numberSectionStyles: 3,

  /**
   * **axisFormatter** - formatting of the axis, this might need adjustment to match your locale and preferences
   */
  axisFormatter: [

  // Within a day
  ['%I:%M', function (d) {
    return d.getHours();
  }],
  // Monday a week
  ['w. %U', function (d) {
    return d.getDay() === 1;
  }],
  // Day within a week (not monday)
  ['%a %d', function (d) {
    return d.getDay() && d.getDate() !== 1;
  }],
  // within a month
  ['%b %d', function (d) {
    return d.getDate() !== 1;
  }],
  // Month
  ['%m-%y', function (d) {
    return d.getMonth();
  }]]
},
classDiagram: {},
gitGraph: {},
info: {}

};

(0, _logger.setLogLevel)(config.logLevel);

function parse(text) {

var graphType = _utils2.default.detectType(text);
var parser;

switch (graphType) {
  case 'gitGraph':
    parser = _gitGraph2.default;
    parser.parser.yy = _gitGraphAst2.default;
    break;
  case 'graph':
    parser = _flow2.default;
    parser.parser.yy = _graphDb2.default;
    break;
  case 'dotGraph':
    parser = _dot2.default;
    parser.parser.yy = _graphDb2.default;
    break;
  case 'sequenceDiagram':
    parser = _sequenceDiagram2.default;
    parser.parser.yy = _sequenceDb2.default;
    break;
  case 'info':
    parser = _example2.default;
    parser.parser.yy = _exampleDb2.default;
    break;
  case 'gantt':
    parser = _gantt2.default;
    parser.parser.yy = _ganttDb2.default;
    break;
  case 'classDiagram':
    parser = _classDiagram2.default;
    parser.parser.yy = _classDb2.default;
    break;
}

parser.parser.yy.parseError = function (str, hash) {
  var error = { str: str, hash: hash };
  throw error;
};

parser.parse(text);

}

/**

* ## version
* Function returning version information
* @returns {string} A string containing the version info
*/

var version = exports.version = function version() {

return _package2.default.version;

};

var encodeEntities = exports.encodeEntities = function encodeEntities(text) {

var txt = text;

txt = txt.replace(/style.*:\S*#.*;/g, function (s) {
  var innerTxt = s.substring(0, s.length - 1);
  return innerTxt;
});
txt = txt.replace(/classDef.*:\S*#.*;/g, function (s) {
  var innerTxt = s.substring(0, s.length - 1);
  return innerTxt;
});

txt = txt.replace(/#\w+;/g, function (s) {
  var innerTxt = s.substring(1, s.length - 1);

  var isInt = /^\+?\d+$/.test(innerTxt);
  if (isInt) {
    return 'fl°°' + innerTxt + '¶ß';
  } else {
    return 'fl°' + innerTxt + '¶ß';
  }
});

return txt;

};

var decodeEntities = exports.decodeEntities = function decodeEntities(text) {

var txt = text;

txt = txt.replace(/fl°°/g, function () {
  return '&#';
});
txt = txt.replace(/fl°/g, function () {
  return '&';
});
txt = txt.replace(/¶ß/g, function () {
  return ';';
});

return txt;

}; /**

* ##render
* Function that renders an svg with a graph from a chart definition. Usage example below.
*
* ```
* mermaidAPI.initialize({
*      startOnLoad:true
*  });
*  $(function(){
*      var graphDefinition = 'graph TB\na-->b';
*      var cb = function(svgGraph){
*          console.log(svgGraph);
*      };
*      mermaidAPI.render('id1',graphDefinition,cb);
*  });
*```
* @param id the id of the element to be rendered
* @param txt the graph definition
* @param cb callback which is called after rendering is finished with the svg code as inparam.
* @param container selector to element in which a div with the graph temporarily will be inserted. In one is
* provided a hidden div will be inserted in the body of the page instead. The element will be removed when rendering is
* completed.
*/

var render = function render(id, txt, cb, container) {

if (typeof container !== 'undefined') {
  container.innerHTML = '';

  _d2.default.select(container).append('div').attr('id', 'd' + id).append('svg').attr('id', id).attr('width', '100%').attr('xmlns', 'http://www.w3.org/2000/svg').append('g');
} else {
  var _element = document.querySelector('#' + 'd' + id);
  if (_element) {
    _element.innerHTML = '';
  }

  _d2.default.select('body').append('div').attr('id', 'd' + id).append('svg').attr('id', id).attr('width', '100%').attr('xmlns', 'http://www.w3.org/2000/svg').append('g');
}

window.txt = txt;
txt = encodeEntities(txt);

var element = _d2.default.select('#d' + id).node();
var graphType = _utils2.default.detectType(txt);
var classes = {};
switch (graphType) {
  case 'gitGraph':
    config.flowchart.arrowMarkerAbsolute = config.arrowMarkerAbsolute;
    _gitGraphRenderer2.default.setConf(config.gitGraph);
    _gitGraphRenderer2.default.draw(txt, id, false);
    break;
  case 'graph':
    config.flowchart.arrowMarkerAbsolute = config.arrowMarkerAbsolute;
    _flowRenderer2.default.setConf(config.flowchart);
    _flowRenderer2.default.draw(txt, id, false);
    if (config.cloneCssStyles) {
      classes = _flowRenderer2.default.getClasses(txt, false);
      _utils2.default.cloneCssStyles(element.firstChild, classes);
    }
    break;
  case 'dotGraph':
    config.flowchart.arrowMarkerAbsolute = config.arrowMarkerAbsolute;
    _flowRenderer2.default.setConf(config.flowchart);
    _flowRenderer2.default.draw(txt, id, true);
    if (config.cloneCssStyles) {
      classes = _flowRenderer2.default.getClasses(txt, true);
      _utils2.default.cloneCssStyles(element.firstChild, classes);
    }
    break;
  case 'sequenceDiagram':
    config.sequenceDiagram.arrowMarkerAbsolute = config.arrowMarkerAbsolute;
    _sequenceRenderer2.default.setConf(config.sequenceDiagram);
    _sequenceRenderer2.default.draw(txt, id);
    if (config.cloneCssStyles) {
      _utils2.default.cloneCssStyles(element.firstChild, []);
    }
    break;
  case 'gantt':
    config.gantt.arrowMarkerAbsolute = config.arrowMarkerAbsolute;
    _ganttRenderer2.default.setConf(config.gantt);
    _ganttRenderer2.default.draw(txt, id);
    if (config.cloneCssStyles) {
      _utils2.default.cloneCssStyles(element.firstChild, []);
    }
    break;
  case 'classDiagram':
    config.classDiagram.arrowMarkerAbsolute = config.arrowMarkerAbsolute;
    _classRenderer2.default.setConf(config.classDiagram);
    _classRenderer2.default.draw(txt, id);
    if (config.cloneCssStyles) {
      _utils2.default.cloneCssStyles(element.firstChild, []);
    }
    break;
  case 'info':
    config.info.arrowMarkerAbsolute = config.arrowMarkerAbsolute;
    _exampleRenderer2.default.draw(txt, id, version());
    if (config.cloneCssStyles) {
      _utils2.default.cloneCssStyles(element.firstChild, []);
    }
    break;
}

_d2.default.select('#d' + id).selectAll('foreignobject div').attr('xmlns', 'http://www.w3.org/1999/xhtml');

var url = '';
if (config.arrowMarkerAbsolute) {
  url = window.location.protocol + '//' + window.location.host + window.location.pathname + window.location.search;
  url = url.replace(/\(/g, '\\(');
  url = url.replace(/\)/g, '\\)');
}

// Fix for when the base tag is used
var svgCode = _d2.default.select('#d' + id).node().innerHTML.replace(/url\(#arrowhead/g, 'url(' + url + '#arrowhead', 'g');

svgCode = decodeEntities(svgCode);

if (typeof cb !== 'undefined') {
  cb(svgCode, _graphDb2.default.bindFunctions);
} else {
  _logger.logger.warn('CB = undefined!');
}

var node = _d2.default.select('#d' + id).node();
if (node !== null && typeof node.remove === 'function') {
  _d2.default.select('#d' + id).node().remove();
}

return svgCode;

};

function render2(id, text, cb, containerElement) {

try {
  if (arguments.length === 1) {
    text = id;
    id = 'mermaidId0';
  }

  if (typeof document === 'undefined') {
    // Todo handle rendering serverside using phantomjs
  } else {
    // In browser
    return render(id, text, cb, containerElement);
  }
} catch (e) {
  _logger.logger.warn(e);
}

}

var setConf = function setConf(cnf) {

// Top level initially mermaid, gflow, sequenceDiagram and gantt
var lvl1Keys = Object.keys(cnf);
var i;
for (i = 0; i < lvl1Keys.length; i++) {
  if (_typeof(cnf[lvl1Keys[i]]) === 'object') {
    var lvl2Keys = Object.keys(cnf[lvl1Keys[i]]);

    var j;
    for (j = 0; j < lvl2Keys.length; j++) {
      _logger.logger.debug('Setting conf ', lvl1Keys[i], '-', lvl2Keys[j]);
      if (typeof config[lvl1Keys[i]] === 'undefined') {
        config[lvl1Keys[i]] = {};
      }
      _logger.logger.debug('Setting config: ' + lvl1Keys[i] + ' ' + lvl2Keys[j] + ' to ' + cnf[lvl1Keys[i]][lvl2Keys[j]]);
      config[lvl1Keys[i]][lvl2Keys[j]] = cnf[lvl1Keys[i]][lvl2Keys[j]];
    }
  } else {
    config[lvl1Keys[i]] = cnf[lvl1Keys[i]];
  }
}

};

function initialize(options) {

_logger.logger.debug('Initializing mermaidAPI');
// Update default config with options supplied at initialization
if ((typeof options === 'undefined' ? 'undefined' : _typeof(options)) === 'object') {
  setConf(options);
}
(0, _logger.setLogLevel)(config.logLevel);

}

function getConfig() {

return config;

}

var mermaidAPI = {

render: render2,
parse: parse,
initialize: initialize,
detectType: _utils2.default.detectType,
getConfig: getConfig

};

exports.default = mermaidAPI;

/***/ }), /* 202 */ /***/ (function(module, exports, webpack_require) {

var map = {

"./af": 39,
"./af.js": 39,
"./ar": 40,
"./ar-dz": 41,
"./ar-dz.js": 41,
"./ar-kw": 42,
"./ar-kw.js": 42,
"./ar-ly": 43,
"./ar-ly.js": 43,
"./ar-ma": 44,
"./ar-ma.js": 44,
"./ar-sa": 45,
"./ar-sa.js": 45,
"./ar-tn": 46,
"./ar-tn.js": 46,
"./ar.js": 40,
"./az": 47,
"./az.js": 47,
"./be": 48,
"./be.js": 48,
"./bg": 49,
"./bg.js": 49,
"./bn": 50,
"./bn.js": 50,
"./bo": 51,
"./bo.js": 51,
"./br": 52,
"./br.js": 52,
"./bs": 53,
"./bs.js": 53,
"./ca": 54,
"./ca.js": 54,
"./cs": 55,
"./cs.js": 55,
"./cv": 56,
"./cv.js": 56,
"./cy": 57,
"./cy.js": 57,
"./da": 58,
"./da.js": 58,
"./de": 59,
"./de-at": 60,
"./de-at.js": 60,
"./de-ch": 61,
"./de-ch.js": 61,
"./de.js": 59,
"./dv": 62,
"./dv.js": 62,
"./el": 63,
"./el.js": 63,
"./en-au": 64,
"./en-au.js": 64,
"./en-ca": 65,
"./en-ca.js": 65,
"./en-gb": 66,
"./en-gb.js": 66,
"./en-ie": 67,
"./en-ie.js": 67,
"./en-nz": 68,
"./en-nz.js": 68,
"./eo": 69,
"./eo.js": 69,
"./es": 70,
"./es-do": 71,
"./es-do.js": 71,
"./es.js": 70,
"./et": 72,
"./et.js": 72,
"./eu": 73,
"./eu.js": 73,
"./fa": 74,
"./fa.js": 74,
"./fi": 75,
"./fi.js": 75,
"./fo": 76,
"./fo.js": 76,
"./fr": 77,
"./fr-ca": 78,
"./fr-ca.js": 78,
"./fr-ch": 79,
"./fr-ch.js": 79,
"./fr.js": 77,
"./fy": 80,
"./fy.js": 80,
"./gd": 81,
"./gd.js": 81,
"./gl": 82,
"./gl.js": 82,
"./gom-latn": 83,
"./gom-latn.js": 83,
"./he": 84,
"./he.js": 84,
"./hi": 85,
"./hi.js": 85,
"./hr": 86,
"./hr.js": 86,
"./hu": 87,
"./hu.js": 87,
"./hy-am": 88,
"./hy-am.js": 88,
"./id": 89,
"./id.js": 89,
"./is": 90,
"./is.js": 90,
"./it": 91,
"./it.js": 91,
"./ja": 92,
"./ja.js": 92,
"./jv": 93,
"./jv.js": 93,
"./ka": 94,
"./ka.js": 94,
"./kk": 95,
"./kk.js": 95,
"./km": 96,
"./km.js": 96,
"./kn": 97,
"./kn.js": 97,
"./ko": 98,
"./ko.js": 98,
"./ky": 99,
"./ky.js": 99,
"./lb": 100,
"./lb.js": 100,
"./lo": 101,
"./lo.js": 101,
"./lt": 102,
"./lt.js": 102,
"./lv": 103,
"./lv.js": 103,
"./me": 104,
"./me.js": 104,
"./mi": 105,
"./mi.js": 105,
"./mk": 106,
"./mk.js": 106,
"./ml": 107,
"./ml.js": 107,
"./mr": 108,
"./mr.js": 108,
"./ms": 109,
"./ms-my": 110,
"./ms-my.js": 110,
"./ms.js": 109,
"./my": 111,
"./my.js": 111,
"./nb": 112,
"./nb.js": 112,
"./ne": 113,
"./ne.js": 113,
"./nl": 114,
"./nl-be": 115,
"./nl-be.js": 115,
"./nl.js": 114,
"./nn": 116,
"./nn.js": 116,
"./pa-in": 117,
"./pa-in.js": 117,
"./pl": 118,
"./pl.js": 118,
"./pt": 119,
"./pt-br": 120,
"./pt-br.js": 120,
"./pt.js": 119,
"./ro": 121,
"./ro.js": 121,
"./ru": 122,
"./ru.js": 122,
"./sd": 123,
"./sd.js": 123,
"./se": 124,
"./se.js": 124,
"./si": 125,
"./si.js": 125,
"./sk": 126,
"./sk.js": 126,
"./sl": 127,
"./sl.js": 127,
"./sq": 128,
"./sq.js": 128,
"./sr": 129,
"./sr-cyrl": 130,
"./sr-cyrl.js": 130,
"./sr.js": 129,
"./ss": 131,
"./ss.js": 131,
"./sv": 132,
"./sv.js": 132,
"./sw": 133,
"./sw.js": 133,
"./ta": 134,
"./ta.js": 134,
"./te": 135,
"./te.js": 135,
"./tet": 136,
"./tet.js": 136,
"./th": 137,
"./th.js": 137,
"./tl-ph": 138,
"./tl-ph.js": 138,
"./tlh": 139,
"./tlh.js": 139,
"./tr": 140,
"./tr.js": 140,
"./tzl": 141,
"./tzl.js": 141,
"./tzm": 142,
"./tzm-latn": 143,
"./tzm-latn.js": 143,
"./tzm.js": 142,
"./uk": 144,
"./uk.js": 144,
"./ur": 145,
"./ur.js": 145,
"./uz": 146,
"./uz-latn": 147,
"./uz-latn.js": 147,
"./uz.js": 146,
"./vi": 148,
"./vi.js": 148,
"./x-pseudo": 149,
"./x-pseudo.js": 149,
"./yo": 150,
"./yo.js": 150,
"./zh-cn": 151,
"./zh-cn.js": 151,
"./zh-hk": 152,
"./zh-hk.js": 152,
"./zh-tw": 153,
"./zh-tw.js": 153

}; function webpackContext(req) {

return __webpack_require__(webpackContextResolve(req));

}; function webpackContextResolve(req) {

var id = map[req];
if(!(id + 1)) // check for number or string
        throw new Error("Cannot find module '" + req + "'.");
return id;

}; webpackContext.keys = function webpackContextKeys() {

return Object.keys(map);

}; webpackContext.resolve = webpackContextResolve; module.exports = webpackContext; webpackContext.id = 202;

/***/ }), /* 203 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.draw = exports.getClasses = exports.addEdges = exports.addVertices = exports.setConf = undefined;

var _graphDb = webpack_require(154);

var _graphDb2 = _interopRequireDefault(_graphDb);

var _flow = webpack_require(156);

var _flow2 = _interopRequireDefault(_flow);

var _dot = webpack_require(157);

var _dot2 = _interopRequireDefault(_dot);

var _d = webpack_require(6);

var _d2 = _interopRequireDefault(_d);

var _dagreD3Renderer = webpack_require(204);

var _dagreD3Renderer2 = _interopRequireDefault(_dagreD3Renderer);

var _logger = webpack_require(1);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var conf = {}; var setConf = exports.setConf = function setConf(cnf) {

var keys = Object.keys(cnf);
var i;
for (i = 0; i < keys.length; i++) {
  conf[keys[i]] = cnf[keys[i]];
}

};

/**

* Function that adds the vertices found in the graph definition to the graph to be rendered.
* @param vert Object containing the vertices.
* @param g The graph that is to be drawn.
*/

var addVertices = exports.addVertices = function addVertices(vert, g) {

var keys = Object.keys(vert);

var styleFromStyleArr = function styleFromStyleArr(styleStr, arr) {
  var i;
  // Create a compound style definition from the style definitions found for the node in the graph definition
  for (i = 0; i < arr.length; i++) {
    if (typeof arr[i] !== 'undefined') {
      styleStr = styleStr + arr[i] + ';';
    }
  }

  return styleStr;
};

// Iterate through each item in the vertice object (containing all the vertices found) in the graph definition
keys.forEach(function (id) {
  var vertice = vert[id];
  var verticeText;

  /**
   * Variable for storing the classes for the vertice
   * @type {string}
   */
  var classStr = '';

  if (vertice.classes.length > 0) {
    classStr = vertice.classes.join(' ');
  }

  /**
   * Variable for storing the extracted style for the vertice
   * @type {string}
   */
  var style = '';
  // Create a compound style definition from the style definitions found for the node in the graph definition
  style = styleFromStyleArr(style, vertice.styles);

  // Use vertice id as text in the box if no text is provided by the graph definition
  if (typeof vertice.text === 'undefined') {
    verticeText = vertice.id;
  } else {
    verticeText = vertice.text;
  }

  var labelTypeStr = '';
  if (conf.htmlLabels) {
    labelTypeStr = 'html';
    verticeText = verticeText.replace(/fa:fa[\w-]+/g, function (s) {
      return '<i class="fa ' + s.substring(3) + '"></i>';
    });
  } else {
    var svgLabel = document.createElementNS('http://www.w3.org/2000/svg', 'text');

    var rows = verticeText.split(/<br>/);

    var j = 0;
    for (j = 0; j < rows.length; j++) {
      var tspan = document.createElementNS('http://www.w3.org/2000/svg', 'tspan');
      tspan.setAttributeNS('http://www.w3.org/XML/1998/namespace', 'xml:space', 'preserve');
      tspan.setAttribute('dy', '1em');
      tspan.setAttribute('x', '1');
      tspan.textContent = rows[j];
      svgLabel.appendChild(tspan);
    }

    labelTypeStr = 'svg';
    verticeText = svgLabel;
  }

  var radious = 0;
  var _shape = '';

  // Set the shape based parameters
  switch (vertice.type) {
    case 'round':
      radious = 5;
      _shape = 'rect';
      break;
    case 'square':
      _shape = 'rect';
      break;
    case 'diamond':
      _shape = 'question';
      break;
    case 'odd':
      _shape = 'rect_left_inv_arrow';
      break;
    case 'odd_right':
      _shape = 'rect_left_inv_arrow';
      break;
    case 'circle':
      _shape = 'circle';
      break;
    case 'ellipse':
      _shape = 'ellipse';
      break;
    case 'group':
      _shape = 'rect';
      // Need to create a text node if using svg labels, see #367
      verticeText = conf.htmlLabels ? '' : document.createElementNS('http://www.w3.org/2000/svg', 'text');
      break;
    default:
      _shape = 'rect';
  }
  // Add the node
  g.setNode(vertice.id, { labelType: labelTypeStr, shape: _shape, label: verticeText, rx: radious, ry: radious, 'class': classStr, style: style, id: vertice.id });
});

};

/**

* Add edges to graph based on parsed graph defninition
* @param {Object} edges The edges to add to the graph
* @param {Object} g The graph object
*/

var addEdges = exports.addEdges = function addEdges(edges, g) {

var cnt = 0;

var defaultStyle;
if (typeof edges.defaultStyle !== 'undefined') {
  defaultStyle = edges.defaultStyle.toString().replace(/,/g, ';');
}

edges.forEach(function (edge) {
  cnt++;
  var edgeData = {};

  // Set link type for rendering
  if (edge.type === 'arrow_open') {
    edgeData.arrowhead = 'none';
  } else {
    edgeData.arrowhead = 'normal';
  }

  var style = '';

  if (typeof edge.style !== 'undefined') {
    edge.style.forEach(function (s) {
      style = style + s + ';';
    });
  } else {
    switch (edge.stroke) {
      case 'normal':
        style = 'fill:none';
        if (typeof defaultStyle !== 'undefined') {
          style = defaultStyle;
        }
        break;
      case 'dotted':
        style = 'stroke: #333; fill:none;stroke-width:2px;stroke-dasharray:3;';
        break;
      case 'thick':
        style = 'stroke: #333; stroke-width: 3.5px;fill:none';
        break;
    }
  }
  edgeData.style = style;

  if (typeof edge.interpolate !== 'undefined') {
    edgeData.lineInterpolate = edge.interpolate;
  } else {
    if (typeof edges.defaultInterpolate !== 'undefined') {
      edgeData.lineInterpolate = edges.defaultInterpolate;
    }
  }

  if (typeof edge.text === 'undefined') {
    if (typeof edge.style !== 'undefined') {
      edgeData.arrowheadStyle = 'fill: #333';
    }
  } else {
    edgeData.arrowheadStyle = 'fill: #333';
    if (typeof edge.style === 'undefined') {
      edgeData.labelpos = 'c';
      if (conf.htmlLabels) {
        edgeData.labelType = 'html';
        edgeData.label = '<span class="edgeLabel">' + edge.text + '</span>';
      } else {
        edgeData.labelType = 'text';
        edgeData.style = 'stroke: #333; stroke-width: 1.5px;fill:none';
        edgeData.label = edge.text.replace(/<br>/g, '\n');
      }
    } else {
      edgeData.label = edge.text.replace(/<br>/g, '\n');
    }
  }
  // Add the edge to the graph
  g.setEdge(edge.start, edge.end, edgeData, cnt);
});

};

/**

* Returns the all the styles from classDef statements in the graph definition.
* @returns {object} classDef styles
*/

var getClasses = exports.getClasses = function getClasses(text, isDot) {

var parser;
_graphDb2.default.clear();
if (isDot) {
  parser = _dot2.default.parser;
} else {
  parser = _flow2.default.parser;
}
parser.yy = _graphDb2.default;

// Parse the graph definition
parser.parse(text);

var classes = _graphDb2.default.getClasses();

// Add default class if undefined
if (typeof classes.default === 'undefined') {
  classes.default = { id: 'default' };
  classes.default.styles = [];
  classes.default.clusterStyles = ['rx:4px', 'fill: rgb(255, 255, 222)', 'rx: 4px', 'stroke: rgb(170, 170, 51)', 'stroke-width: 1px'];
  classes.default.nodeLabelStyles = ['fill:#000', 'stroke:none', 'font-weight:300', 'font-family:"Helvetica Neue",Helvetica,Arial,sans-serf', 'font-size:14px'];
  classes.default.edgeLabelStyles = ['fill:#000', 'stroke:none', 'font-weight:300', 'font-family:"Helvetica Neue",Helvetica,Arial,sans-serf', 'font-size:14px'];
}
return classes;

};

/**

* Draws a flowchart in the tag with id: id based on the graph definition in text.
* @param text
* @param id
*/

var draw = exports.draw = function draw(text, id, isDot) {

_logger.logger.debug('Drawing flowchart');
var parser;
_graphDb2.default.clear();
if (isDot) {
  parser = _dot2.default.parser;
} else {
  parser = _flow2.default.parser;
}
parser.yy = _graphDb2.default;

// Parse the graph definition
try {
  parser.parse(text);
} catch (err) {
  _logger.logger.debug('Parsing failed');
}

// Fetch the default direction, use TD if none was found
var dir;
dir = _graphDb2.default.getDirection();
if (typeof dir === 'undefined') {
  dir = 'TD';
}

// Create the input mermaid.graph
var g = new _dagreD3Renderer2.default.graphlib.Graph({
  multigraph: true,
  compound: true
}).setGraph({
  rankdir: dir,
  marginx: 20,
  marginy: 20

}).setDefaultEdgeLabel(function () {
  return {};
});

var subG;
var subGraphs = _graphDb2.default.getSubGraphs();
var i = 0;
for (i = subGraphs.length - 1; i >= 0; i--) {
  subG = subGraphs[i];
  _graphDb2.default.addVertex(subG.id, subG.title, 'group', undefined);
}

// Fetch the verices/nodes and edges/links from the parsed graph definition
var vert = _graphDb2.default.getVertices();

var edges = _graphDb2.default.getEdges();

i = 0;
var j;
for (i = subGraphs.length - 1; i >= 0; i--) {
  subG = subGraphs[i];

  _d2.default.selectAll('cluster').append('text');

  for (j = 0; j < subG.nodes.length; j++) {
    g.setParent(subG.nodes[j], subG.id);
  }
}
addVertices(vert, g);
addEdges(edges, g);

// Create the renderer
var Render = _dagreD3Renderer2.default.render;
var render = new Render();

// Add custom shape for rhombus type of boc (decision)
render.shapes().question = function (parent, bbox, node) {
  var w = bbox.width;
  var h = bbox.height;
  var s = (w + h) * 0.8;
  var points = [{ x: s / 2, y: 0 }, { x: s, y: -s / 2 }, { x: s / 2, y: -s }, { x: 0, y: -s / 2 }];
  var shapeSvg = parent.insert('polygon', ':first-child').attr('points', points.map(function (d) {
    return d.x + ',' + d.y;
  }).join(' ')).attr('rx', 5).attr('ry', 5).attr('transform', 'translate(' + -s / 2 + ',' + s * 2 / 4 + ')');
  node.intersect = function (point) {
    return _dagreD3Renderer2.default.intersect.polygon(node, points, point);
  };
  return shapeSvg;
};

// Add custom shape for box with inverted arrow on left side
render.shapes().rect_left_inv_arrow = function (parent, bbox, node) {
  var w = bbox.width;
  var h = bbox.height;
  var points = [{ x: -h / 2, y: 0 }, { x: w, y: 0 }, { x: w, y: -h }, { x: -h / 2, y: -h }, { x: 0, y: -h / 2 }];
  var shapeSvg = parent.insert('polygon', ':first-child').attr('points', points.map(function (d) {
    return d.x + ',' + d.y;
  }).join(' ')).attr('transform', 'translate(' + -w / 2 + ',' + h * 2 / 4 + ')');
  node.intersect = function (point) {
    return _dagreD3Renderer2.default.intersect.polygon(node, points, point);
  };
  return shapeSvg;
};

// Add custom shape for box with inverted arrow on right side
render.shapes().rect_right_inv_arrow = function (parent, bbox, node) {
  var w = bbox.width;
  var h = bbox.height;
  var points = [{ x: 0, y: 0 }, { x: w + h / 2, y: 0 }, { x: w, y: -h / 2 }, { x: w + h / 2, y: -h }, { x: 0, y: -h }];
  var shapeSvg = parent.insert('polygon', ':first-child').attr('points', points.map(function (d) {
    return d.x + ',' + d.y;
  }).join(' ')).attr('transform', 'translate(' + -w / 2 + ',' + h * 2 / 4 + ')');
  node.intersect = function (point) {
    return _dagreD3Renderer2.default.intersect.polygon(node, points, point);
  };
  return shapeSvg;
};

// Add our custom arrow - an empty arrowhead
render.arrows().none = function normal(parent, id, edge, type) {
  var marker = parent.append('marker').attr('id', id).attr('viewBox', '0 0 10 10').attr('refX', 9).attr('refY', 5).attr('markerUnits', 'strokeWidth').attr('markerWidth', 8).attr('markerHeight', 6).attr('orient', 'auto');

  var path = marker.append('path').attr('d', 'M 0 0 L 0 0 L 0 0 z');
  _dagreD3Renderer2.default.util.applyStyle(path, edge[type + 'Style']);
};

// Override normal arrowhead defined in d3. Remove style & add class to allow css styling.
render.arrows().normal = function normal(parent, id, edge, type) {
  var marker = parent.append('marker').attr('id', id).attr('viewBox', '0 0 10 10').attr('refX', 9).attr('refY', 5).attr('markerUnits', 'strokeWidth').attr('markerWidth', 8).attr('markerHeight', 6).attr('orient', 'auto');

  marker.append('path').attr('d', 'M 0 0 L 10 5 L 0 10 z').attr('class', 'arrowheadPath').style('stroke-width', 1).style('stroke-dasharray', '1,0');
};

// Set up an SVG group so that we can translate the final graph.
var svg = _d2.default.select('#' + id);

// Run the renderer. This is what draws the final graph.
var element = _d2.default.select('#' + id + ' g');
render(element, g);

element.selectAll('g.node').attr('title', function () {
  return _graphDb2.default.getTooltip(this.id);
});

if (conf.useMaxWidth) {
  // Center the graph
  svg.attr('height', '100%');
  svg.attr('width', conf.width);
  svg.attr('viewBox', '0 0 ' + (g.graph().width + 20) + ' ' + (g.graph().height + 20));
  svg.attr('style', 'max-width:' + (g.graph().width + 20) + 'px;');
} else {
  // Center the graph
  svg.attr('height', g.graph().height);
  if (typeof conf.width === 'undefined') {
    svg.attr('width', g.graph().width);
  } else {
    svg.attr('width', conf.width);
  }
  svg.attr('viewBox', '0 0 ' + (g.graph().width + 20) + ' ' + (g.graph().height + 20));
}

// Index nodes
_graphDb2.default.indexNodes('subGraph' + i);

for (i = 0; i < subGraphs.length; i++) {
  subG = subGraphs[i];

  if (subG.title !== 'undefined') {
    var clusterRects = document.querySelectorAll('#' + id + ' #' + subG.id + ' rect');
    var clusterEl = document.querySelectorAll('#' + id + ' #' + subG.id);

    var xPos = clusterRects[0].x.baseVal.value;
    var yPos = clusterRects[0].y.baseVal.value;
    var width = clusterRects[0].width.baseVal.value;
    var cluster = _d2.default.select(clusterEl[0]);
    var te = cluster.append('text');
    te.attr('x', xPos + width / 2);
    te.attr('y', yPos + 14);
    te.attr('fill', 'black');
    te.attr('stroke', 'none');
    te.attr('id', id + 'Text');
    te.style('text-anchor', 'middle');

    if (typeof subG.title === 'undefined') {
      te.text('Undef');
    } else {
      te.text(subG.title);
    }
  }
}

// Add label rects for non html labels
if (!conf.htmlLabels) {
  var labels = document.querySelectorAll('#' + id + ' .edgeLabel .label');
  var k;
  for (k = 0; k < labels.length; k++) {
    var label = labels[i];

    // Get dimensions of label
    var dim = label.getBBox();

    var rect = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
    rect.setAttribute('rx', 0);
    rect.setAttribute('ry', 0);
    rect.setAttribute('width', dim.width);
    rect.setAttribute('height', dim.height);
    rect.setAttribute('style', 'fill:#e8e8e8;');

    label.insertBefore(rect, label.firstChild);
  }
}

};

exports.default = {

setConf: setConf,
addVertices: addVertices,
addEdges: addEdges,
getClasses: getClasses,
draw: draw

};

/***/ }), /* 204 */ /***/ (function(module, exports, webpack_require) {

(function webpackUniversalModuleDefinition(root, factory) {

if(true)
        module.exports = factory(__webpack_require__(29), __webpack_require__(17), __webpack_require__(30), __webpack_require__(20));
else if(typeof define === 'function' && define.amd)
        define(["d3", "lodash", "dagre-layout", "graphlib"], factory);
else if(typeof exports === 'object')
        exports["dagreD3"] = factory(require("d3"), require("lodash"), require("dagre-layout"), require("graphlib"));
else
        root["dagreD3"] = factory(root["d3"], root["lodash"], root["dagre-layout"], root["graphlib"]);

})(this, function(WEBPACK_EXTERNAL_MODULE_1, WEBPACK_EXTERNAL_MODULE_2, WEBPACK_EXTERNAL_MODULE_5, WEBPACK_EXTERNAL_MODULE_11) { return /******/ (function(modules) { // webpackBootstrap /******/ // The module cache /******/ var installedModules = {}; /******/ /******/ // The require function /******/ function webpack_require(moduleId) { /******/ /******/ // Check if module is in cache /******/ if(installedModules) { /******/ return installedModules.exports; /******/ } /******/ // Create a new module (and put it into the cache) /******/ var module = installedModules = { /******/ i: moduleId, /******/ l: false, /******/ exports: {} /******/ }; /******/ /******/ // Execute the module function /******/ modules.call(module.exports, module, module.exports, webpack_require); /******/ /******/ // Flag the module as loaded /******/ module.l = true; /******/ /******/ // Return the exports of the module /******/ return module.exports; /******/ } /******/ /******/ /******/ // expose the modules object (webpack_modules) /******/ webpack_require.m = modules; /******/ /******/ // expose the module cache /******/ webpack_require.c = installedModules; /******/ /******/ // define getter function for harmony exports /******/ webpack_require.d = function(exports, name, getter) { /******/ if(!webpack_require.o(exports, name)) { /******/ Object.defineProperty(exports, name, { /******/ configurable: false, /******/ enumerable: true, /******/ get: getter /******/ }); /******/ } /******/ }; /******/ /******/ // getDefaultExport function for compatibility with non-harmony modules /******/ webpack_require.n = function(module) { /******/ var getter = module && module.__esModule ? /******/ function getDefault() { return module; } : /******/ function getModuleExports() { return module; }; /******/ webpack_require.d(getter, 'a', getter); /******/ return getter; /******/ }; /******/ /******/ // Object.prototype.hasOwnProperty.call /******/ webpack_require.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; /******/ /******/ // webpack_public_path /******/ webpack_require.p = “”; /******/ /******/ // Load entry module and return exports /******/ return webpack_require(_webpack_require_.s = 10); /******/ }) /************************************************************************/ /******/ ([ /* 0 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(2);

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* Returns true if the specified node in the graph is a subgraph node. A
* subgraph node is one that contains other nodes.
*/

function isSubgraph(g, v) {

return !!g.children(v).length;

}

function edgeToId(e) {

return escapeId(e.v) + ':' + escapeId(e.w) + ':' + escapeId(e.name);

}

var ID_DELIM = /:/g; function escapeId(str) {

return str ? String(str).replace(ID_DELIM, '\\:') : '';

}

function applyStyle(dom, styleFn) {

if (styleFn) {
  dom.attr('style', styleFn);
}

}

function applyClass(dom, classFn, otherClasses) {

if (classFn) {
  dom.attr('class', classFn).attr('class', otherClasses + ' ' + dom.attr('class'));
}

}

function applyTransition(selection, g) {

var graph = g.graph();

if (_lodash2.default.isPlainObject(graph)) {
  var transition = graph.transition;
  if (_lodash2.default.isFunction(transition)) {
    return transition(selection);
  }
}

return selection;

}

// Public utility functions exports.default = {

isSubgraph: isSubgraph,
edgeToId: edgeToId,
applyStyle: applyStyle,
applyClass: applyClass,
applyTransition: applyTransition

};

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

module.exports = webpack_require(29);

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

module.exports = webpack_require(17);

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); function intersectEllipse(node, rx, ry, point) {

// Formulae from: http://mathworld.wolfram.com/Ellipse-LineIntersection.html

var cx = node.x;
var cy = node.y;

var px = cx - point.x;
var py = cy - point.y;

var det = Math.sqrt(rx * rx * py * py + ry * ry * px * px);

var dx = Math.abs(rx * ry * px / det);
if (point.x < cx) {
  dx = -dx;
}
var dy = Math.abs(rx * ry * py / det);
if (point.y < cy) {
  dy = -dy;
}

return { x: cx + dx, y: cy + dy };

}

exports.default = intersectEllipse;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _addTextLabel = webpack_require(19);

var _addTextLabel2 = _interopRequireDefault(_addTextLabel);

var _addHtmlLabel = webpack_require(20);

var _addHtmlLabel2 = _interopRequireDefault(_addHtmlLabel);

var _addSvgLabel = webpack_require(21);

var _addSvgLabel2 = _interopRequireDefault(_addSvgLabel);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function addLabel(root, node, location) {

var label = node.label;
var labelSvg = root.append('g');

// Allow the label to be a string, a function that returns a DOM element, or
// a DOM element itself.
if (node.labelType === 'svg') {
  (0, _addSvgLabel2.default)(labelSvg, node);
} else if (typeof label !== 'string' || node.labelType === 'html') {
  (0, _addHtmlLabel2.default)(labelSvg, node);
} else {
  (0, _addTextLabel2.default)(labelSvg, node);
}

var labelBBox = labelSvg.node().getBBox();
var y = void 0;
switch (location) {
  case 'top':
    y = -node.height / 2;
    break;
  case 'bottom':
    y = node.height / 2 - labelBBox.height;
    break;
  default:
    y = -labelBBox.height / 2;
}
labelSvg.attr('transform', 'translate(' + -labelBBox.width / 2 + ',' + y + ')');

return labelSvg;

}

exports.default = addLabel;

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

module.exports = webpack_require(30);

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); function intersectNode(node, point) {

return node.intersect(point);

}

exports.default = intersectNode;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _intersectEllipse = webpack_require(3);

var _intersectEllipse2 = _interopRequireDefault(_intersectEllipse);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function intersectCircle(node, rx, point) {

return (0, _intersectEllipse2.default)(node, rx, rx, point);

}

exports.default = intersectCircle;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _intersectLine = webpack_require(13);

var _intersectLine2 = _interopRequireDefault(_intersectLine);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* Returns the point ({x, y}) at which the point argument intersects with the
* node argument assuming that it has the shape specified by polygon.
*/

function intersectPolygon(node, polyPoints, point) {

var x1 = node.x;
var y1 = node.y;

var intersections = [];

var minX = Number.POSITIVE_INFINITY;
var minY = Number.POSITIVE_INFINITY;
polyPoints.forEach(function (entry) {
  minX = Math.min(minX, entry.x);
  minY = Math.min(minY, entry.y);
});

var left = x1 - node.width / 2 - minX;
var top = y1 - node.height / 2 - minY;

for (var i = 0; i < polyPoints.length; i += 1) {
  var p1 = polyPoints[i];
  var p2 = polyPoints[i < polyPoints.length - 1 ? i + 1 : 0];
  var intersect = (0, _intersectLine2.default)(node, point, { x: left + p1.x, y: top + p1.y }, { x: left + p2.x, y: top + p2.y });
  if (intersect) {
    intersections.push(intersect);
  }
}

if (!intersections.length) {
  console.log('NO INTERSECTION FOUND, RETURN NODE CENTER', node);
  return node;
}

if (intersections.length > 1) {
  // More intersections, find the one nearest to edge end point
  intersections.sort(function (p, q) {
    var pdx = p.x - point.x;
    var pdy = p.y - point.y;
    var distp = Math.sqrt(pdx * pdx + pdy * pdy);

    var qdx = q.x - point.x;
    var qdy = q.y - point.y;
    var distq = Math.sqrt(qdx * qdx + qdy * qdy);

    return distp < distq ? -1 : distp === distq ? 0 : 1;
  });
}
return intersections[0];

}

exports.default = intersectPolygon;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); function intersectRect(node, point) {

var x = node.x;
var y = node.y;

// Rectangle intersection algorithm from:
// http://math.stackexchange.com/questions/108113/find-edge-between-two-boxes
var dx = point.x - x;
var dy = point.y - y;
var w = node.width / 2;
var h = node.height / 2;

var sx = void 0,
    sy = void 0;
if (Math.abs(dy) * w > Math.abs(dx) * h) {
  // Intersection is top or bottom of rect.
  if (dy < 0) {
    h = -h;
  }
  sx = dy === 0 ? 0 : h * dx / dy;
  sy = h;
} else {
  // Intersection is left or right of rect.
  if (dx < 0) {
    w = -w;
  }
  sx = w;
  sy = dx === 0 ? 0 : w * dy / dx;
}

return { x: x + sx, y: y + sy };

}

exports.default = intersectRect;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _d = webpack_require(1);

var _d2 = _interopRequireDefault(_d);

var _graphlib = webpack_require(11);

var _graphlib2 = _interopRequireDefault(_graphlib);

var _dagreLayout = webpack_require(5);

var _dagreLayout2 = _interopRequireDefault(_dagreLayout);

var _intersect = webpack_require(12);

var _intersect2 = _interopRequireDefault(_intersect);

var _render = webpack_require(14);

var _render2 = _interopRequireDefault(_render);

var _util = webpack_require(0);

var _util2 = _interopRequireDefault(_util);

var _package = webpack_require(27);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {

d3: _d2.default,
graphlib: _graphlib2.default,
dagre: _dagreLayout2.default,
intersect: _intersect2.default,
render: _render2.default,
util: _util2.default,
version: _package.version

};

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

module.exports = webpack_require(20);

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _intersectNode = webpack_require(6);

var _intersectNode2 = _interopRequireDefault(_intersectNode);

var _intersectCircle = webpack_require(7);

var _intersectCircle2 = _interopRequireDefault(_intersectCircle);

var _intersectEllipse = webpack_require(3);

var _intersectEllipse2 = _interopRequireDefault(_intersectEllipse);

var _intersectPolygon = webpack_require(8);

var _intersectPolygon2 = _interopRequireDefault(_intersectPolygon);

var _intersectRect = webpack_require(9);

var _intersectRect2 = _interopRequireDefault(_intersectRect);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {

node: _intersectNode2.default,
circle: _intersectCircle2.default,
ellipse: _intersectEllipse2.default,
polygon: _intersectPolygon2.default,
rect: _intersectRect2.default

};

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); /*

* Returns the point at which two lines, p and q, intersect or returns
* undefined if they do not intersect.
*/

function intersectLine(p1, p2, q1, q2) {

// Algorithm from J. Avro, (ed.) Graphics Gems, No 2, Morgan Kaufmann, 1994,
// p7 and p473.

// Compute a1, b1, c1, where line joining points 1 and 2 is F(x,y) = a1 x +
// b1 y + c1 = 0.
var a1 = p2.y - p1.y;
var b1 = p1.x - p2.x;
var c1 = p2.x * p1.y - p1.x * p2.y;

// Compute r3 and r4.
var r3 = a1 * q1.x + b1 * q1.y + c1;
var r4 = a1 * q2.x + b1 * q2.y + c1;

// Check signs of r3 and r4. If both point 3 and point 4 lie on
// same side of line 1, the line segments do not intersect.
if (r3 !== 0 && r4 !== 0 && sameSign(r3, r4)) {
  return; /* DONT_INTERSECT */
}

// Compute a2, b2, c2 where line joining points 3 and 4 is G(x,y) = a2 x + b2 y + c2 = 0
var a2 = q2.y - q1.y;
var b2 = q1.x - q2.x;
var c2 = q2.x * q1.y - q1.x * q2.y;

// Compute r1 and r2
var r1 = a2 * p1.x + b2 * p1.y + c2;
var r2 = a2 * p2.x + b2 * p2.y + c2;

// Check signs of r1 and r2. If both point 1 and point 2 lie
// on same side of second line segment, the line segments do
// not intersect.
if (r1 !== 0 && r2 !== 0 && sameSign(r1, r2)) {
  return; /* DONT_INTERSECT */
}

// Line segments intersect: compute intersection point.
var denom = a1 * b2 - a2 * b1;
if (denom === 0) {
  return; /* COLLINEAR */
}

var offset = Math.abs(denom / 2);

// The denom/2 is to get rounding instead of truncating. It
// is added or subtracted to the numerator, depending upon the
// sign of the numerator.
var num = b1 * c2 - b2 * c1;
var x = num < 0 ? (num - offset) / denom : (num + offset) / denom;

num = a2 * c1 - a1 * c2;
var y = num < 0 ? (num - offset) / denom : (num + offset) / denom;

return { x: x, y: y };

}

function sameSign(r1, r2) {

return r1 * r2 > 0;

}

exports.default = intersectLine;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(2);

var _lodash2 = _interopRequireDefault(_lodash);

var _dagreLayout = webpack_require(5);

var _positionNodes = webpack_require(15);

var _positionNodes2 = _interopRequireDefault(_positionNodes);

var _positionEdgeLabels = webpack_require(16);

var _positionEdgeLabels2 = _interopRequireDefault(_positionEdgeLabels);

var _positionClusters = webpack_require(17);

var _positionClusters2 = _interopRequireDefault(_positionClusters);

var _createNodes2 = webpack_require(18);

var _createNodes3 = _interopRequireDefault(_createNodes2);

var _createClusters2 = webpack_require(22);

var _createClusters3 = _interopRequireDefault(_createClusters2);

var _createEdgeLabels2 = webpack_require(23);

var _createEdgeLabels3 = _interopRequireDefault(_createEdgeLabels2);

var _createEdgePaths2 = webpack_require(24);

var _createEdgePaths3 = _interopRequireDefault(_createEdgePaths2);

var _shapes2 = webpack_require(25);

var _shapes3 = _interopRequireDefault(_shapes2);

var _arrows2 = webpack_require(26);

var _arrows3 = _interopRequireDefault(_arrows2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

// This design is based on bost.ocks.org/mike/chart/. function render() {

var _createNodes = _createNodes3.default;
var _createClusters = _createClusters3.default;
var _createEdgeLabels = _createEdgeLabels3.default;
var _createEdgePaths = _createEdgePaths3.default;
var _shapes = _shapes3.default;
var _arrows = _arrows3.default;

var fn = function fn(svg, g) {
  preProcessGraph(g);

  var outputGroup = createOrSelectGroup(svg, 'output');
  var clustersGroup = createOrSelectGroup(outputGroup, 'clusters');
  var edgePathsGroup = createOrSelectGroup(outputGroup, 'edgePaths');
  var edgeLabels = _createEdgeLabels(createOrSelectGroup(outputGroup, 'edgeLabels'), g);
  var nodes = _createNodes(createOrSelectGroup(outputGroup, 'nodes'), g, _shapes);

  (0, _dagreLayout.layout)(g);

  (0, _positionNodes2.default)(nodes, g);
  (0, _positionEdgeLabels2.default)(edgeLabels, g);
  _createEdgePaths(edgePathsGroup, g, _arrows);

  var clusters = _createClusters(clustersGroup, g);
  (0, _positionClusters2.default)(clusters, g);

  postProcessGraph(g);
};

fn.createNodes = function (value) {
  if (!arguments.length) {
    return _createNodes;
  }
  _createNodes = value;
  return fn;
};

fn.createClusters = function (value) {
  if (!arguments.length) {
    return _createClusters;
  }
  _createClusters = value;
  return fn;
};

fn.createEdgeLabels = function (value) {
  if (!arguments.length) {
    return _createEdgeLabels;
  }
  _createEdgeLabels = value;
  return fn;
};

fn.createEdgePaths = function (value) {
  if (!arguments.length) {
    return _createEdgePaths;
  }
  _createEdgePaths = value;
  return fn;
};

fn.shapes = function (value) {
  if (!arguments.length) {
    return _shapes;
  }
  _shapes = value;
  return fn;
};

fn.arrows = function (value) {
  if (!arguments.length) {
    return _arrows;
  }
  _arrows = value;
  return fn;
};

return fn;

}

var NODE_DEFAULT_ATTRS = {

paddingLeft: 10,
paddingRight: 10,
paddingTop: 10,
paddingBottom: 10,
rx: 0,
ry: 0,
shape: 'rect'

};

var EDGE_DEFAULT_ATTRS = {

arrowhead: 'normal',
lineInterpolate: 'linear'

};

function preProcessGraph(g) {

g.nodes().forEach(function (v) {
  var node = g.node(v);
  if (!_lodash2.default.has(node, 'label') && !g.children(v).length) {
    node.label = v;
  }

  if (_lodash2.default.has(node, 'paddingX')) {
    _lodash2.default.defaults(node, {
      paddingLeft: node.paddingX,
      paddingRight: node.paddingX
    });
  }

  if (_lodash2.default.has(node, 'paddingY')) {
    _lodash2.default.defaults(node, {
      paddingTop: node.paddingY,
      paddingBottom: node.paddingY
    });
  }

  if (_lodash2.default.has(node, 'padding')) {
    _lodash2.default.defaults(node, {
      paddingLeft: node.padding,
      paddingRight: node.padding,
      paddingTop: node.padding,
      paddingBottom: node.padding
    });
  }

  _lodash2.default.defaults(node, NODE_DEFAULT_ATTRS);

  _lodash2.default.each(['paddingLeft', 'paddingRight', 'paddingTop', 'paddingBottom'], function (k) {
    node[k] = Number(node[k]);
  });

  // Save dimensions for restore during post-processing
  if (_lodash2.default.has(node, 'width')) {
    node._prevWidth = node.width;
  }
  if (_lodash2.default.has(node, 'height')) {
    node._prevHeight = node.height;
  }
});

g.edges().forEach(function (e) {
  var edge = g.edge(e);
  if (!_lodash2.default.has(edge, 'label')) {
    edge.label = '';
  }
  _lodash2.default.defaults(edge, EDGE_DEFAULT_ATTRS);
});

}

function postProcessGraph(g) {

_lodash2.default.each(g.nodes(), function (v) {
  var node = g.node(v);

  // Restore original dimensions
  if (_lodash2.default.has(node, '_prevWidth')) {
    node.width = node._prevWidth;
  } else {
    delete node.width;
  }

  if (_lodash2.default.has(node, '_prevHeight')) {
    node.height = node._prevHeight;
  } else {
    delete node.height;
  }

  delete node._prevWidth;
  delete node._prevHeight;
});

}

function createOrSelectGroup(root, name) {

var selection = root.select('g.' + name);
if (selection.empty()) {
  selection = root.append('g').attr('class', name);
}
return selection;

}

exports.default = render;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _d = webpack_require(1);

var _d2 = _interopRequireDefault(_d);

var _util = webpack_require(0);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function positionNodes(selection, g) {

var created = selection.filter(function () {
  return !_d2.default.select(this).classed('update');
});

function translate(v) {
  var node = g.node(v);
  return 'translate(' + node.x + ',' + node.y + ')';
}

created.attr('transform', translate);

_util2.default.applyTransition(selection, g).style('opacity', 1).attr('transform', translate);

}

exports.default = positionNodes;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _d = webpack_require(1);

var _d2 = _interopRequireDefault(_d);

var _lodash = webpack_require(2);

var _lodash2 = _interopRequireDefault(_lodash);

var _util = webpack_require(0);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function positionEdgeLabels(selection, g) {

var created = selection.filter(function () {
  return !_d2.default.select(this).classed('update');
});

function translate(e) {
  var edge = g.edge(e);
  return _lodash2.default.has(edge, 'x') ? 'translate(' + edge.x + ',' + edge.y + ')' : '';
}

created.attr('transform', translate);

_util2.default.applyTransition(selection, g).style('opacity', 1).attr('transform', translate);

}

exports.default = positionEdgeLabels;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _d = webpack_require(1);

var _d2 = _interopRequireDefault(_d);

var _util = webpack_require(0);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function positionClusters(selection, g) {

var created = selection.filter(function () {
  return !_d2.default.select(this).classed('update');
});

function translate(v) {
  var node = g.node(v);
  return 'translate(' + node.x + ',' + node.y + ')';
}

created.attr('transform', translate);

_util2.default.applyTransition(selection, g).style('opacity', 1).attr('transform', translate);

_util2.default.applyTransition(created.selectAll('rect'), g).attr('width', function (v) {
  return g.node(v).width;
}).attr('height', function (v) {
  return g.node(v).height;
}).attr('x', function (v) {
  var node = g.node(v);
  return -node.width / 2;
}).attr('y', function (v) {
  var node = g.node(v);
  return -node.height / 2;
});

}

exports.default = positionClusters;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _lodash = webpack_require(2);

var _lodash2 = _interopRequireDefault(_lodash);

var _d = webpack_require(1);

var _d2 = _interopRequireDefault(_d);

var _addLabel = webpack_require(4);

var _addLabel2 = _interopRequireDefault(_addLabel);

var _util = webpack_require(0);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function createNodes(selection, g, shapes) {

var simpleNodes = g.nodes().filter(function (v) {
  return !_util2.default.isSubgraph(g, v);
});
var svgNodes = selection.selectAll('g.node').data(simpleNodes, function (v) {
  return v;
}).classed('update', true);

svgNodes.selectAll('*').remove();
svgNodes.enter().append('g').attr('class', 'node').style('opacity', 0);
svgNodes.each(function (v) {
  var node = g.node(v);
  var thisGroup = _d2.default.select(this);
  var labelGroup = thisGroup.append('g').attr('class', 'label');
  var labelDom = (0, _addLabel2.default)(labelGroup, node);
  var shape = shapes[node.shape];
  var bbox = _lodash2.default.pick(labelDom.node().getBBox(), 'width', 'height');

  node.elem = this;

  if (node.id) {
    thisGroup.attr('id', node.id);
  }
  if (node.labelId) {
    labelGroup.attr('id', node.labelId);
  }
  _util2.default.applyClass(thisGroup, node['class'], (thisGroup.classed('update') ? 'update ' : '') + 'node');

  if (_lodash2.default.has(node, 'width')) {
    bbox.width = node.width;
  }
  if (_lodash2.default.has(node, 'height')) {
    bbox.height = node.height;
  }

  bbox.width += node.paddingLeft + node.paddingRight;
  bbox.height += node.paddingTop + node.paddingBottom;
  labelGroup.attr('transform', 'translate(' + (node.paddingLeft - node.paddingRight) / 2 + ',' + (node.paddingTop - node.paddingBottom) / 2 + ')');

  var shapeSvg = shape(_d2.default.select(this), bbox, node);
  _util2.default.applyStyle(shapeSvg, node.style);

  var shapeBBox = shapeSvg.node().getBBox();
  node.width = shapeBBox.width;
  node.height = shapeBBox.height;
});

_util2.default.applyTransition(svgNodes.exit(), g).style('opacity', 0).remove();

return svgNodes;

}

exports.default = createNodes;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _util = webpack_require(0);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/*

* Attaches a text label to the specified root. Handles escape sequences.
*/

function addTextLabel(root, node) {

var domNode = root.append('text');

var lines = processEscapeSequences(node.label).split('\n');
for (var i = 0; i < lines.length; i += 1) {
  domNode.append('tspan').attr('xml:space', 'preserve').attr('dy', '1em').attr('x', '1').text(lines[i]);
}

_util2.default.applyStyle(domNode, node.labelStyle);

return domNode;

}

function processEscapeSequences(text) {

var newText = '';
var escaped = false;
var ch = null;
for (var i = 0; i < text.length; i += 1) {
  ch = text[i];
  if (escaped) {
    switch (ch) {
      case 'n':
        newText += '\n';break;
      default:
        newText += ch;
    }
    escaped = false;
  } else if (ch === '\\') {
    escaped = true;
  } else {
    newText += ch;
  }
}
return newText;

}

exports.default = addTextLabel;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _typeof = typeof Symbol === “function” && typeof Symbol.iterator === “symbol” ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === “function” && obj.constructor === Symbol && obj !== Symbol.prototype ? “symbol” : typeof obj; };

var _util = webpack_require(0);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function addHtmlLabel(root, node) {

var fo = root.append('foreignObject').attr('width', '100000');

var div = fo.append('xhtml:div');
div.attr('xmlns', 'http://www.w3.org/1999/xhtml');

var label = node.label;
switch (typeof label === 'undefined' ? 'undefined' : _typeof(label)) {
  case 'function':
    div.insert(label);
    break;
  case 'object':
    // Currently we assume this is a DOM object.
    div.insert(function () {
      return label;
    });
    break;
  default:
    div.html(label);
}

_util2.default.applyStyle(div, node.labelStyle);
div.style('display', 'inline-block');
// Fix for firefox
div.style('white-space', 'nowrap');

var client = div[0][0].getBoundingClientRect();
fo.attr('width', client.width).attr('height', client.height);

return fo;

}

exports.default = addHtmlLabel;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _util = webpack_require(0);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function addSVGLabel(root, node) {

var domNode = root;

domNode.node().appendChild(node.label);

_util2.default.applyStyle(domNode, node.labelStyle);

return domNode;

}

exports.default = addSVGLabel;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _d = webpack_require(1);

var _d2 = _interopRequireDefault(_d);

var _util = webpack_require(0);

var _util2 = _interopRequireDefault(_util);

var _addLabel = webpack_require(4);

var _addLabel2 = _interopRequireDefault(_addLabel);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function createClusters(selection, g) {

var clusters = g.nodes().filter(function (v) {
  return _util2.default.isSubgraph(g, v);
});
var svgClusters = selection.selectAll('g.cluster').data(clusters, function (v) {
  return v;
});

svgClusters.selectAll('*').remove();
svgClusters.enter().append('g').attr('class', 'cluster').attr('id', function (v) {
  var node = g.node(v);
  return node.id;
}).style('opacity', 0);

_util2.default.applyTransition(svgClusters, g).style('opacity', 1);

svgClusters.each(function (v) {
  var node = g.node(v);
  var thisGroup = _d2.default.select(this);
  _d2.default.select(this).append('rect');
  var labelGroup = thisGroup.append('g').attr('class', 'label');
  (0, _addLabel2.default)(labelGroup, node, node.clusterLabelPos);
});

svgClusters.selectAll('rect').each(function (c) {
  var node = g.node(c);
  var domCluster = _d2.default.select(this);
  _util2.default.applyStyle(domCluster, node.style);
});

_util2.default.applyTransition(svgClusters.exit(), g).style('opacity', 0).remove();

return svgClusters;

}

exports.default = createClusters;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _d = webpack_require(1);

var _d2 = _interopRequireDefault(_d);

var _lodash = webpack_require(2);

var _lodash2 = _interopRequireDefault(_lodash);

var _addLabel = webpack_require(4);

var _addLabel2 = _interopRequireDefault(_addLabel);

var _util = webpack_require(0);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function createEdgeLabels(selection, g) {

var svgEdgeLabels = selection.selectAll('g.edgeLabel').data(g.edges(), function (e) {
  return _util2.default.edgeToId(e);
}).classed('update', true);

svgEdgeLabels.selectAll('*').remove();
svgEdgeLabels.enter().append('g').classed('edgeLabel', true).style('opacity', 0);
svgEdgeLabels.each(function (e) {
  var edge = g.edge(e);
  var label = (0, _addLabel2.default)(_d2.default.select(this), g.edge(e), 0, 0).classed('label', true);
  var bbox = label.node().getBBox();

  if (edge.labelId) {
    label.attr('id', edge.labelId);
  }
  if (!_lodash2.default.has(edge, 'width')) {
    edge.width = bbox.width;
  }
  if (!_lodash2.default.has(edge, 'height')) {
    edge.height = bbox.height;
  }
});

_util2.default.applyTransition(svgEdgeLabels.exit(), g).style('opacity', 0).remove();

return svgEdgeLabels;

}

exports.default = createEdgeLabels;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _d = webpack_require(1);

var _d2 = _interopRequireDefault(_d);

var _lodash = webpack_require(2);

var _lodash2 = _interopRequireDefault(_lodash);

var _intersectNode = webpack_require(6);

var _intersectNode2 = _interopRequireDefault(_intersectNode);

var _util = webpack_require(0);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function createEdgePaths(selection, g, arrows) {

var svgPaths = selection.selectAll('g.edgePath').data(g.edges(), function (e) {
  return _util2.default.edgeToId(e);
}).classed('update', true);

enter(svgPaths, g);
exit(svgPaths, g);

_util2.default.applyTransition(svgPaths, g).style('opacity', 1);

// Save DOM element in the path group, and set ID and class
svgPaths.each(function (e) {
  var domEdge = _d2.default.select(this);
  var edge = g.edge(e);
  edge.elem = this;

  if (edge.id) {
    domEdge.attr('id', edge.id);
  }

  _util2.default.applyClass(domEdge, edge['class'], (domEdge.classed('update') ? 'update ' : '') + 'edgePath');
});

svgPaths.selectAll('path.path').each(function (e) {
  var edge = g.edge(e);
  edge.arrowheadId = _lodash2.default.uniqueId('arrowhead');

  var domEdge = _d2.default.select(this).attr('marker-end', function () {
    return 'url(' + makeFragmentRef(window.location.href, edge.arrowheadId) + ')';
  }).style('fill', 'none');

  _util2.default.applyTransition(domEdge, g).attr('d', function (e) {
    return calcPoints(g, e);
  });

  _util2.default.applyStyle(domEdge, edge.style);
});

svgPaths.selectAll('defs *').remove();
svgPaths.selectAll('defs').each(function (e) {
  var edge = g.edge(e);
  var arrowhead = arrows[edge.arrowhead];
  arrowhead(_d2.default.select(this), edge.arrowheadId, edge, 'arrowhead');
});

return svgPaths;

}

function makeFragmentRef(url, fragmentId) {

var baseUrl = url.split('#')[0];
return baseUrl + '#' + fragmentId;

}

function calcPoints(g, e) {

var edge = g.edge(e);
var tail = g.node(e.v);
var head = g.node(e.w);
var points = edge.points.slice(1, edge.points.length - 1);
points.unshift((0, _intersectNode2.default)(tail, points[0]));
points.push((0, _intersectNode2.default)(head, points[points.length - 1]));

return createLine(edge, points);

}

function createLine(edge, points) {

var line = _d2.default.svg.line().x(function (d) {
  return d.x;
}).y(function (d) {
  return d.y;
});

if (_lodash2.default.has(edge, 'lineInterpolate')) {
  line.interpolate(edge.lineInterpolate);
}

if (_lodash2.default.has(edge, 'lineTension')) {
  line.tension(Number(edge.lineTension));
}

return line(points);

}

function getCoords(elem) {

var bbox = elem.getBBox();
var matrix = elem.ownerSVGElement.getScreenCTM().inverse().multiply(elem.getScreenCTM()).translate(bbox.width / 2, bbox.height / 2);
return { x: matrix.e, y: matrix.f };

}

function enter(svgPaths, g) {

var svgPathsEnter = svgPaths.enter().append('g').attr('class', 'edgePath').style('opacity', 0);
svgPathsEnter.append('path').attr('class', 'path').attr('d', function (e) {
  var edge = g.edge(e);
  var sourceElem = g.node(e.v).elem;
  var points = _lodash2.default.range(edge.points.length).map(function () {
    return getCoords(sourceElem);
  });
  return createLine(edge, points);
});
svgPathsEnter.append('defs');

}

function exit(svgPaths, g) {

var svgPathExit = svgPaths.exit();
_util2.default.applyTransition(svgPathExit, g).style('opacity', 0).remove();

_util2.default.applyTransition(svgPathExit.select('path.path'), g).attr('d', function (e) {
  var source = g.node(e.v);

  if (source) {
    var points = _lodash2.default.range(this.getTotalLength()).map(function () {
      return source;
    });
    return createLine({}, points);
  } else {
    return _d2.default.select(this).attr('d');
  }
});

}

exports.default = createEdgePaths;

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _intersectRect = webpack_require(9);

var _intersectRect2 = _interopRequireDefault(_intersectRect);

var _intersectEllipse = webpack_require(3);

var _intersectEllipse2 = _interopRequireDefault(_intersectEllipse);

var _intersectCircle = webpack_require(7);

var _intersectCircle2 = _interopRequireDefault(_intersectCircle);

var _intersectPolygon = webpack_require(8);

var _intersectPolygon2 = _interopRequireDefault(_intersectPolygon);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function rect(parent, bbox, node) {

var shapeSvg = parent.insert('rect', ':first-child').attr('rx', node.rx).attr('ry', node.ry).attr('x', -bbox.width / 2).attr('y', -bbox.height / 2).attr('width', bbox.width).attr('height', bbox.height);

node.intersect = function (point) {
  return (0, _intersectRect2.default)(node, point);
};

return shapeSvg;

}

function ellipse(parent, bbox, node) {

var rx = bbox.width / 2;
var ry = bbox.height / 2;
var shapeSvg = parent.insert('ellipse', ':first-child').attr('x', -bbox.width / 2).attr('y', -bbox.height / 2).attr('rx', rx).attr('ry', ry);

node.intersect = function (point) {
  return (0, _intersectEllipse2.default)(node, rx, ry, point);
};

return shapeSvg;

}

function circle(parent, bbox, node) {

var r = Math.max(bbox.width, bbox.height) / 2;
var shapeSvg = parent.insert('circle', ':first-child').attr('x', -bbox.width / 2).attr('y', -bbox.height / 2).attr('r', r);

node.intersect = function (point) {
  return (0, _intersectCircle2.default)(node, r, point);
};

return shapeSvg;

}

// Circumscribe an ellipse for the bounding box with a diamond shape. I derived // the function to calculate the diamond shape from: // mathforum.org/kb/message.jspa?messageID=3750236 function diamond(parent, bbox, node) {

var w = bbox.width * Math.SQRT2 / 2;
var h = bbox.height * Math.SQRT2 / 2;
var points = [{ x: 0, y: -h }, { x: -w, y: 0 }, { x: 0, y: h }, { x: w, y: 0 }];
var shapeSvg = parent.insert('polygon', ':first-child').attr('points', points.map(function (p) {
  return p.x + ',' + p.y;
}).join(' '));

node.intersect = function (p) {
  return (0, _intersectPolygon2.default)(node, points, p);
};

return shapeSvg;

}

exports.default = {

rect: rect,
ellipse: ellipse,
circle: circle,
diamond: diamond

};

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

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

});

var _util = webpack_require(0);

var _util2 = _interopRequireDefault(_util);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function normal(parent, id, edge, type) {

var marker = parent.append('marker').attr('id', id).attr('viewBox', '0 0 10 10').attr('refX', 9).attr('refY', 5).attr('markerUnits', 'strokeWidth').attr('markerWidth', 8).attr('markerHeight', 6).attr('orient', 'auto');

var path = marker.append('path').attr('d', 'M 0 0 L 10 5 L 0 10 z').style('stroke-width', 1).style('stroke-dasharray', '1,0');
_util2.default.applyStyle(path, edge[type + 'Style']);
if (edge[type + 'Class']) {
  path.attr('class', edge[type + 'Class']);
}

}

function vee(parent, id, edge, type) {

var marker = parent.append('marker').attr('id', id).attr('viewBox', '0 0 10 10').attr('refX', 9).attr('refY', 5).attr('markerUnits', 'strokeWidth').attr('markerWidth', 8).attr('markerHeight', 6).attr('orient', 'auto');

var path = marker.append('path').attr('d', 'M 0 0 L 10 5 L 0 10 L 4 5 z').style('stroke-width', 1).style('stroke-dasharray', '1,0');
_util2.default.applyStyle(path, edge[type + 'Style']);
if (edge[type + 'Class']) {
  path.attr('class', edge[type + 'Class']);
}

}

function undirected(parent, id, edge, type) {

var marker = parent.append('marker').attr('id', id).attr('viewBox', '0 0 10 10').attr('refX', 9).attr('refY', 5).attr('markerUnits', 'strokeWidth').attr('markerWidth', 8).attr('markerHeight', 6).attr('orient', 'auto');

var path = marker.append('path').attr('d', 'M 0 5 L 10 5').style('stroke-width', 1).style('stroke-dasharray', '1,0');
_util2.default.applyStyle(path, edge[type + 'Style']);
if (edge[type + 'Class']) {
  path.attr('class', edge[type + 'Class']);
}

}

exports.default = {

normal: normal,
vee: vee,
undirected: undirected,
default: normal

};

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

module.exports = {“name”:“dagre-d3-renderer”,“version”:“0.4.23”,“description”:“A D3-based renderer for Dagre”,“keywords”:,“main”:“dist/dagre-d3.core.js”,“scripts”:{“lint”:“standard”,“karma”:“node -r babel-register ./node_modules/.bin/karma start –single-run”,“test”:“yarn lint && yarn karma && phantomjs test/demo-test.js”,“upgrade”:“yarn upgrade –latest && yarn remove d3 && yarn add d3@3.5.17”,“build”:“node -r babel-register node_modules/.bin/webpack –progress –colors”,“build:watch”:“yarn build –watch”},“dependencies”:{“d3”:“3.5.17”,“dagre-layout”:“^0.8.0”,“graphlib”:“^2.1.1”,“lodash”:“^4.17.4”},“devDependencies”:{“babel-core”:“^6.26.0”,“babel-loader”:“^7.1.2”,“babel-preset-env”:“^1.6.0”,“babel-preset-es2015”:“^6.24.1”,“chai”:“^4.1.2”,“karma”:“^1.7.1”,“karma-chrome-launcher”:“^2.2.0”,“karma-firefox-launcher”:“^1.0.1”,“karma-mocha”:“^1.3.0”,“karma-safari-launcher”:“^1.0.0”,“mocha”:“^3.5.0”,“phantomjs-prebuilt”:“^2.1.15”,“standard”:“^10.0.3”,“webpack”:“^3.5.5”,“webpack-node-externals”:“^1.6.0”},“repository”:{“type”:“git”,“url”:“github.com/tylingsoft/dagre-d3-renderer.git”},“license”:“MIT”,“standard”:{“ignore”:[“dist/*/.js”]}}

/***/ }) /******/ ])[“default”]; });

/***/ }), /* 205 */ /***/ (function(module, exports, webpack_require) {

// Includes only the “core” of graphlib module.exports = {

Graph: __webpack_require__(31),
version: __webpack_require__(206)

};

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

module.exports = '2.1.1';

/***/ }), /* 207 */ /***/ (function(module, exports, webpack_require) {

var _ = webpack_require(4),

Graph = __webpack_require__(31);

module.exports = {

write: write,
read: read

};

function write(g) {

var json = {
  options: {
    directed: g.isDirected(),
    multigraph: g.isMultigraph(),
    compound: g.isCompound()
  },
  nodes: writeNodes(g),
  edges: writeEdges(g)
};
if (!_.isUndefined(g.graph())) {
  json.value = _.clone(g.graph());
}
return json;

}

function writeNodes(g) {

return _.map(g.nodes(), function(v) {
  var nodeValue = g.node(v),
      parent = g.parent(v),
      node = { v: v };
  if (!_.isUndefined(nodeValue)) {
    node.value = nodeValue;
  }
  if (!_.isUndefined(parent)) {
    node.parent = parent;
  }
  return node;
});

}

function writeEdges(g) {

return _.map(g.edges(), function(e) {
  var edgeValue = g.edge(e),
      edge = { v: e.v, w: e.w };
  if (!_.isUndefined(e.name)) {
    edge.name = e.name;
  }
  if (!_.isUndefined(edgeValue)) {
    edge.value = edgeValue;
  }
  return edge;
});

}

function read(json) {

var g = new Graph(json.options).setGraph(json.value);
_.each(json.nodes, function(entry) {
  g.setNode(entry.v, entry.value);
  if (entry.parent) {
    g.setParent(entry.v, entry.parent);
  }
});
_.each(json.edges, function(entry) {
  g.setEdge({ v: entry.v, w: entry.w, name: entry.name }, entry.value);
});
return g;

}

/***/ }), /* 208 */ /***/ (function(module, exports, webpack_require) {

module.exports = {

components: __webpack_require__(209),
dijkstra: __webpack_require__(158),
dijkstraAll: __webpack_require__(210),
findCycles: __webpack_require__(211),
floydWarshall: __webpack_require__(212),
isAcyclic: __webpack_require__(213),
postorder: __webpack_require__(214),
preorder: __webpack_require__(215),
prim: __webpack_require__(216),
tarjan: __webpack_require__(160),
topsort: __webpack_require__(161)

};

/***/ }), /* 209 */ /***/ (function(module, exports, webpack_require) {

var _ = webpack_require(4);

module.exports = components;

function components(g) {

var visited = {},
    cmpts = [],
    cmpt;

function dfs(v) {
  if (_.has(visited, v)) return;
  visited[v] = true;
  cmpt.push(v);
  _.each(g.successors(v), dfs);
  _.each(g.predecessors(v), dfs);
}

_.each(g.nodes(), function(v) {
  cmpt = [];
  dfs(v);
  if (cmpt.length) {
    cmpts.push(cmpt);
  }
});

return cmpts;

}

/***/ }), /* 210 */ /***/ (function(module, exports, webpack_require) {

var dijkstra = webpack_require(158),

_ = __webpack_require__(4);

module.exports = dijkstraAll;

function dijkstraAll(g, weightFunc, edgeFunc) {

return _.transform(g.nodes(), function(acc, v) {
  acc[v] = dijkstra(g, v, weightFunc, edgeFunc);
}, {});

}

/***/ }), /* 211 */ /***/ (function(module, exports, webpack_require) {

var _ = webpack_require(4),

tarjan = __webpack_require__(160);

module.exports = findCycles;

function findCycles(g) {

return _.filter(tarjan(g), function(cmpt) {
  return cmpt.length > 1 || (cmpt.length === 1 && g.hasEdge(cmpt[0], cmpt[0]));
});

}

/***/ }), /* 212 */ /***/ (function(module, exports, webpack_require) {

var _ = webpack_require(4);

module.exports = floydWarshall;

var DEFAULT_WEIGHT_FUNC = _.constant(1);

function floydWarshall(g, weightFn, edgeFn) {

return runFloydWarshall(g,
                        weightFn || DEFAULT_WEIGHT_FUNC,
                        edgeFn || function(v) { return g.outEdges(v); });

}

function runFloydWarshall(g, weightFn, edgeFn) {

var results = {},
    nodes = g.nodes();

nodes.forEach(function(v) {
  results[v] = {};
  results[v][v] = { distance: 0 };
  nodes.forEach(function(w) {
    if (v !== w) {
      results[v][w] = { distance: Number.POSITIVE_INFINITY };
    }
  });
  edgeFn(v).forEach(function(edge) {
    var w = edge.v === v ? edge.w : edge.v,
        d = weightFn(edge);
    results[v][w] = { distance: d, predecessor: v };
  });
});

nodes.forEach(function(k) {
  var rowK = results[k];
  nodes.forEach(function(i) {
    var rowI = results[i];
    nodes.forEach(function(j) {
      var ik = rowI[k];
      var kj = rowK[j];
      var ij = rowI[j];
      var altDistance = ik.distance + kj.distance;
      if (altDistance < ij.distance) {
        ij.distance = altDistance;
        ij.predecessor = kj.predecessor;
      }
    });
  });
});

return results;

}

/***/ }), /* 213 */ /***/ (function(module, exports, webpack_require) {

var topsort = webpack_require(161);

module.exports = isAcyclic;

function isAcyclic(g) {

try {
  topsort(g);
} catch (e) {
  if (e instanceof topsort.CycleException) {
    return false;
  }
  throw e;
}
return true;

}

/***/ }), /* 214 */ /***/ (function(module, exports, webpack_require) {

var dfs = webpack_require(162);

module.exports = postorder;

function postorder(g, vs) {

return dfs(g, vs, "post");

}

/***/ }), /* 215 */ /***/ (function(module, exports, webpack_require) {

var dfs = webpack_require(162);

module.exports = preorder;

function preorder(g, vs) {

return dfs(g, vs, "pre");

}

/***/ }), /* 216 */ /***/ (function(module, exports, webpack_require) {

var _ = webpack_require(4),

Graph = __webpack_require__(31),
PriorityQueue = __webpack_require__(159);

module.exports = prim;

function prim(g, weightFunc) {

var result = new Graph(),
    parents = {},
    pq = new PriorityQueue(),
    v;

function updateNeighbors(edge) {
  var w = edge.v === v ? edge.w : edge.v,
      pri = pq.priority(w);
  if (pri !== undefined) {
    var edgeWeight = weightFunc(edge);
    if (edgeWeight < pri) {
      parents[w] = v;
      pq.decrease(w, edgeWeight);
    }
  }
}

if (g.nodeCount() === 0) {
  return result;
}

_.each(g.nodes(), function(v) {
  pq.add(v, Number.POSITIVE_INFINITY);
  result.setNode(v);
});

// Start from an arbitrary node
pq.decrease(g.nodes()[0], 0);

var init = false;
while (pq.size() > 0) {
  v = pq.removeMin();
  if (_.has(parents, v)) {
    result.setEdge(v, parents[v]);
  } else if (init) {
    throw new Error("Input graph is not connected: " + g);
  } else {
    init = true;
  }

  g.nodeEdges(v).forEach(updateNeighbors);
}

return result;

}

/***/ }), /* 217 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.draw = exports.setConf = exports.drawActors = exports.bounds = undefined;

var _svgDraw = webpack_require(218);

var _svgDraw2 = _interopRequireDefault(_svgDraw);

var _logger = webpack_require(1);

var _d = webpack_require(6);

var _d2 = _interopRequireDefault(_d);

var _sequenceDiagram = webpack_require(163);

var _sequenceDb = webpack_require(164);

var _sequenceDb2 = _interopRequireDefault(_sequenceDb);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_sequenceDiagram.parser.yy = _sequenceDb2.default;

var conf = {

diagramMarginX: 50,
diagramMarginY: 30,
// Margin between actors
actorMargin: 50,
// Width of actor boxes
width: 150,
// Height of actor boxes
height: 65,
// Margin around loop boxes
boxMargin: 10,
boxTextMargin: 5,
noteMargin: 10,
// Space between messages
messageMargin: 35,
// mirror actors under diagram
mirrorActors: false,
// Depending on css styling this might need adjustment
// Prolongs the edge of the diagram downwards
bottomMarginAdj: 1,

// width of activation box
activationWidth: 10,

// text placement as: tspan | fo | old only text as before
textPlacement: 'tspan'

};

var bounds = exports.bounds = {

data: {
  startx: undefined,
  stopx: undefined,
  starty: undefined,
  stopy: undefined
},
verticalPos: 0,

sequenceItems: [],
activations: [],
init: function init() {
  this.sequenceItems = [];
  this.activations = [];
  this.data = {
    startx: undefined,
    stopx: undefined,
    starty: undefined,
    stopy: undefined
  };
  this.verticalPos = 0;
},
updateVal: function updateVal(obj, key, val, fun) {
  if (typeof obj[key] === 'undefined') {
    obj[key] = val;
  } else {
    obj[key] = fun(val, obj[key]);
  }
},
updateBounds: function updateBounds(startx, starty, stopx, stopy) {
  var _self = this;
  var cnt = 0;
  function updateFn(type) {
    return function updateItemBounds(item) {
      cnt++;
      // The loop sequenceItems is a stack so the biggest margins in the beginning of the sequenceItems
      var n = _self.sequenceItems.length - cnt + 1;

      _self.updateVal(item, 'starty', starty - n * conf.boxMargin, Math.min);
      _self.updateVal(item, 'stopy', stopy + n * conf.boxMargin, Math.max);

      _self.updateVal(bounds.data, 'startx', startx - n * conf.boxMargin, Math.min);
      _self.updateVal(bounds.data, 'stopx', stopx + n * conf.boxMargin, Math.max);

      if (!(type === 'activation')) {
        _self.updateVal(item, 'startx', startx - n * conf.boxMargin, Math.min);
        _self.updateVal(item, 'stopx', stopx + n * conf.boxMargin, Math.max);

        _self.updateVal(bounds.data, 'starty', starty - n * conf.boxMargin, Math.min);
        _self.updateVal(bounds.data, 'stopy', stopy + n * conf.boxMargin, Math.max);
      }
    };
  }

  this.sequenceItems.forEach(updateFn());
  this.activations.forEach(updateFn('activation'));
},
insert: function insert(startx, starty, stopx, stopy) {
  var _startx, _starty, _stopx, _stopy;

  _startx = Math.min(startx, stopx);
  _stopx = Math.max(startx, stopx);
  _starty = Math.min(starty, stopy);
  _stopy = Math.max(starty, stopy);

  this.updateVal(bounds.data, 'startx', _startx, Math.min);
  this.updateVal(bounds.data, 'starty', _starty, Math.min);
  this.updateVal(bounds.data, 'stopx', _stopx, Math.max);
  this.updateVal(bounds.data, 'stopy', _stopy, Math.max);

  this.updateBounds(_startx, _starty, _stopx, _stopy);
},
newActivation: function newActivation(message, diagram) {
  var actorRect = _sequenceDiagram.parser.yy.getActors()[message.from.actor];
  var stackedSize = actorActivations(message.from.actor).length;
  var x = actorRect.x + conf.width / 2 + (stackedSize - 1) * conf.activationWidth / 2;
  this.activations.push({
    startx: x,
    starty: this.verticalPos + 2,
    stopx: x + conf.activationWidth,
    stopy: undefined,
    actor: message.from.actor,
    anchored: _svgDraw2.default.anchorElement(diagram)
  });
},
endActivation: function endActivation(message) {
  // find most recent activation for given actor
  var lastActorActivationIdx = this.activations.map(function (activation) {
    return activation.actor;
  }).lastIndexOf(message.from.actor);
  var activation = this.activations.splice(lastActorActivationIdx, 1)[0];
  return activation;
},
newLoop: function newLoop(title) {
  this.sequenceItems.push({ startx: undefined, starty: this.verticalPos, stopx: undefined, stopy: undefined, title: title });
},
endLoop: function endLoop() {
  var loop = this.sequenceItems.pop();
  return loop;
},
addSectionToLoop: function addSectionToLoop(message) {
  var loop = this.sequenceItems.pop();
  loop.sections = loop.sections || [];
  loop.sectionTitles = loop.sectionTitles || [];
  loop.sections.push(bounds.getVerticalPos());
  loop.sectionTitles.push(message);
  this.sequenceItems.push(loop);
},
bumpVerticalPos: function bumpVerticalPos(bump) {
  this.verticalPos = this.verticalPos + bump;
  this.data.stopy = this.verticalPos;
},
getVerticalPos: function getVerticalPos() {
  return this.verticalPos;
},
getBounds: function getBounds() {
  return this.data;
}

/**
 * Draws an actor in the diagram with the attaced line
 * @param center - The center of the the actor
 * @param pos The position if the actor in the liost of actors
 * @param description The text in the box
 */

};var drawNote = function drawNote(elem, startx, verticalPos, msg, forceWidth) {

var rect = _svgDraw2.default.getNoteRect();
rect.x = startx;
rect.y = verticalPos;
rect.width = forceWidth || conf.width;
rect.class = 'note';

var g = elem.append('g');
var rectElem = _svgDraw2.default.drawRect(g, rect);

var textObj = _svgDraw2.default.getTextObj();
textObj.x = startx - 4;
textObj.y = verticalPos - 13;
textObj.textMargin = conf.noteMargin;
textObj.dy = '1em';
textObj.text = msg.message;
textObj.class = 'noteText';

var textElem = _svgDraw2.default.drawText(g, textObj, rect.width - conf.noteMargin);

var textHeight = textElem[0][0].getBBox().height;
if (!forceWidth && textHeight > conf.width) {
  textElem.remove();
  g = elem.append('g');

  textElem = _svgDraw2.default.drawText(g, textObj, 2 * rect.width - conf.noteMargin);
  textHeight = textElem[0][0].getBBox().height;
  rectElem.attr('width', 2 * rect.width);
  bounds.insert(startx, verticalPos, startx + 2 * rect.width, verticalPos + 2 * conf.noteMargin + textHeight);
} else {
  bounds.insert(startx, verticalPos, startx + rect.width, verticalPos + 2 * conf.noteMargin + textHeight);
}

rectElem.attr('height', textHeight + 2 * conf.noteMargin);
bounds.bumpVerticalPos(textHeight + 2 * conf.noteMargin);

};

/**

* Draws a message
* @param elem
* @param startx
* @param stopx
* @param verticalPos
* @param txtCenter
* @param msg
*/

var drawMessage = function drawMessage(elem, startx, stopx, verticalPos, msg) {

var g = elem.append('g');
var txtCenter = startx + (stopx - startx) / 2;

var textElem = g.append('text') // text label for the x axis
.attr('x', txtCenter).attr('y', verticalPos - 7).style('text-anchor', 'middle').attr('class', 'messageText').text(msg.message);

var textWidth;

if (typeof textElem[0][0].getBBox !== 'undefined') {
  textWidth = textElem[0][0].getBBox().width;
} else {
  textWidth = textElem[0][0].getBoundingClientRect();
}

var line;

if (startx === stopx) {
  line = g.append('path').attr('d', 'M ' + startx + ',' + verticalPos + ' C ' + (startx + 60) + ',' + (verticalPos - 10) + ' ' + (startx + 60) + ',' + (verticalPos + 30) + ' ' + startx + ',' + (verticalPos + 20));

  bounds.bumpVerticalPos(30);
  var dx = Math.max(textWidth / 2, 100);
  bounds.insert(startx - dx, bounds.getVerticalPos() - 10, stopx + dx, bounds.getVerticalPos());
} else {
  line = g.append('line');
  line.attr('x1', startx);
  line.attr('y1', verticalPos);
  line.attr('x2', stopx);
  line.attr('y2', verticalPos);
  bounds.insert(startx, bounds.getVerticalPos() - 10, stopx, bounds.getVerticalPos());
}
// Make an SVG Container
// Draw the line
if (msg.type === _sequenceDiagram.parser.yy.LINETYPE.DOTTED || msg.type === _sequenceDiagram.parser.yy.LINETYPE.DOTTED_CROSS || msg.type === _sequenceDiagram.parser.yy.LINETYPE.DOTTED_OPEN) {
  line.style('stroke-dasharray', '3, 3');
  line.attr('class', 'messageLine1');
} else {
  line.attr('class', 'messageLine0');
}

var url = '';
if (conf.arrowMarkerAbsolute) {
  url = window.location.protocol + '//' + window.location.host + window.location.pathname + window.location.search;
  url = url.replace(/\(/g, '\\(');
  url = url.replace(/\)/g, '\\)');
}

line.attr('stroke-width', 2);
line.attr('stroke', 'black');
line.style('fill', 'none'); // remove any fill colour
if (msg.type === _sequenceDiagram.parser.yy.LINETYPE.SOLID || msg.type === _sequenceDiagram.parser.yy.LINETYPE.DOTTED) {
  line.attr('marker-end', 'url(' + url + '#arrowhead)');
}

if (msg.type === _sequenceDiagram.parser.yy.LINETYPE.SOLID_CROSS || msg.type === _sequenceDiagram.parser.yy.LINETYPE.DOTTED_CROSS) {
  line.attr('marker-end', 'url(' + url + '#crosshead)');
}

};

var drawActors = exports.drawActors = function drawActors(diagram, actors, actorKeys, verticalPos) {

var i;
// Draw the actors
for (i = 0; i < actorKeys.length; i++) {
  var key = actorKeys[i];

  // Add some rendering data to the object
  actors[key].x = i * conf.actorMargin + i * conf.width;
  actors[key].y = verticalPos;
  actors[key].width = conf.diagramMarginX;
  actors[key].height = conf.diagramMarginY;

  // Draw the box with the attached line
  _svgDraw2.default.drawActor(diagram, actors[key].x, verticalPos, actors[key].description, conf);
  bounds.insert(actors[key].x, verticalPos, actors[key].x + conf.width, conf.height);
}

// Add a margin between the actor boxes and the first arrow
bounds.bumpVerticalPos(conf.height);

};

var setConf = exports.setConf = function setConf(cnf) {

var keys = Object.keys(cnf);

keys.forEach(function (key) {
  conf[key] = cnf[key];
});

};

var actorActivations = function actorActivations(actor) {

return bounds.activations.filter(function (activation) {
  return activation.actor === actor;
});

};

var actorFlowVerticaBounds = function actorFlowVerticaBounds(actor) {

// handle multiple stacked activations for same actor
var actors = _sequenceDiagram.parser.yy.getActors();
var activations = actorActivations(actor);

var left = activations.reduce(function (acc, activation) {
  return Math.min(acc, activation.startx);
}, actors[actor].x + conf.width / 2);
var right = activations.reduce(function (acc, activation) {
  return Math.max(acc, activation.stopx);
}, actors[actor].x + conf.width / 2);
return [left, right];

};

/**

* Draws a flowchart in the tag with id: id based on the graph definition in text.
* @param text
* @param id
*/

var draw = exports.draw = function draw(text, id) {

_sequenceDiagram.parser.yy.clear();
_sequenceDiagram.parser.parse(text + '\n');

bounds.init();
var diagram = _d2.default.select('#' + id);

var startx;
var stopx;
var forceWidth;

// Fetch data from the parsing
var actors = _sequenceDiagram.parser.yy.getActors();
var actorKeys = _sequenceDiagram.parser.yy.getActorKeys();
var messages = _sequenceDiagram.parser.yy.getMessages();
var title = _sequenceDiagram.parser.yy.getTitle();
drawActors(diagram, actors, actorKeys, 0);

// The arrow head definition is attached to the svg once
_svgDraw2.default.insertArrowHead(diagram);
_svgDraw2.default.insertArrowCrossHead(diagram);

function activeEnd(msg, verticalPos) {
  var activationData = bounds.endActivation(msg);
  if (activationData.starty + 18 > verticalPos) {
    activationData.starty = verticalPos - 6;
    verticalPos += 12;
  }
  _svgDraw2.default.drawActivation(diagram, activationData, verticalPos, conf);

  bounds.insert(activationData.startx, verticalPos - 10, activationData.stopx, verticalPos);
}

// var lastMsg

// Draw the messages/signals
messages.forEach(function (msg) {
  var loopData;

  switch (msg.type) {
    case _sequenceDiagram.parser.yy.LINETYPE.NOTE:
      bounds.bumpVerticalPos(conf.boxMargin);

      startx = actors[msg.from].x;
      stopx = actors[msg.to].x;

      if (msg.placement === _sequenceDiagram.parser.yy.PLACEMENT.RIGHTOF) {
        drawNote(diagram, startx + (conf.width + conf.actorMargin) / 2, bounds.getVerticalPos(), msg);
      } else if (msg.placement === _sequenceDiagram.parser.yy.PLACEMENT.LEFTOF) {
        drawNote(diagram, startx - (conf.width + conf.actorMargin) / 2, bounds.getVerticalPos(), msg);
      } else if (msg.to === msg.from) {
        // Single-actor over
        drawNote(diagram, startx, bounds.getVerticalPos(), msg);
      } else {
        // Multi-actor over
        forceWidth = Math.abs(startx - stopx) + conf.actorMargin;
        drawNote(diagram, (startx + stopx + conf.width - forceWidth) / 2, bounds.getVerticalPos(), msg, forceWidth);
      }
      break;
    case _sequenceDiagram.parser.yy.LINETYPE.ACTIVE_START:
      bounds.newActivation(msg, diagram);
      break;
    case _sequenceDiagram.parser.yy.LINETYPE.ACTIVE_END:
      activeEnd(msg, bounds.getVerticalPos());
      break;
    case _sequenceDiagram.parser.yy.LINETYPE.LOOP_START:
      bounds.bumpVerticalPos(conf.boxMargin);
      bounds.newLoop(msg.message);
      bounds.bumpVerticalPos(conf.boxMargin + conf.boxTextMargin);
      break;
    case _sequenceDiagram.parser.yy.LINETYPE.LOOP_END:
      loopData = bounds.endLoop();

      _svgDraw2.default.drawLoop(diagram, loopData, 'loop', conf);
      bounds.bumpVerticalPos(conf.boxMargin);
      break;
    case _sequenceDiagram.parser.yy.LINETYPE.OPT_START:
      bounds.bumpVerticalPos(conf.boxMargin);
      bounds.newLoop(msg.message);
      bounds.bumpVerticalPos(conf.boxMargin + conf.boxTextMargin);
      break;
    case _sequenceDiagram.parser.yy.LINETYPE.OPT_END:
      loopData = bounds.endLoop();

      _svgDraw2.default.drawLoop(diagram, loopData, 'opt', conf);
      bounds.bumpVerticalPos(conf.boxMargin);
      break;
    case _sequenceDiagram.parser.yy.LINETYPE.ALT_START:
      bounds.bumpVerticalPos(conf.boxMargin);
      bounds.newLoop(msg.message);
      bounds.bumpVerticalPos(conf.boxMargin + conf.boxTextMargin);
      break;
    case _sequenceDiagram.parser.yy.LINETYPE.ALT_ELSE:
      bounds.bumpVerticalPos(conf.boxMargin);
      loopData = bounds.addSectionToLoop(msg.message);
      bounds.bumpVerticalPos(conf.boxMargin);
      break;
    case _sequenceDiagram.parser.yy.LINETYPE.ALT_END:
      loopData = bounds.endLoop();

      _svgDraw2.default.drawLoop(diagram, loopData, 'alt', conf);
      bounds.bumpVerticalPos(conf.boxMargin);
      break;
    case _sequenceDiagram.parser.yy.LINETYPE.PAR_START:
      bounds.bumpVerticalPos(conf.boxMargin);
      bounds.newLoop(msg.message);
      bounds.bumpVerticalPos(conf.boxMargin + conf.boxTextMargin);
      break;
    case _sequenceDiagram.parser.yy.LINETYPE.PAR_AND:
      bounds.bumpVerticalPos(conf.boxMargin);
      loopData = bounds.addSectionToLoop(msg.message);
      bounds.bumpVerticalPos(conf.boxMargin);
      break;
    case _sequenceDiagram.parser.yy.LINETYPE.PAR_END:
      loopData = bounds.endLoop();
      _svgDraw2.default.drawLoop(diagram, loopData, 'par', conf);
      bounds.bumpVerticalPos(conf.boxMargin);
      break;
    default:
      try {
        // lastMsg = msg
        bounds.bumpVerticalPos(conf.messageMargin);
        var fromBounds = actorFlowVerticaBounds(msg.from);
        var toBounds = actorFlowVerticaBounds(msg.to);
        var fromIdx = fromBounds[0] <= toBounds[0] ? 1 : 0;
        var toIdx = fromBounds[0] < toBounds[0] ? 0 : 1;
        startx = fromBounds[fromIdx];
        stopx = toBounds[toIdx];

        var verticalPos = bounds.getVerticalPos();
        drawMessage(diagram, startx, stopx, verticalPos, msg);
        var allBounds = fromBounds.concat(toBounds);
        bounds.insert(Math.min.apply(null, allBounds), verticalPos, Math.max.apply(null, allBounds), verticalPos);
      } catch (e) {
        console.error('error while drawing message', e);
      }
  }
});

if (conf.mirrorActors) {
  // Draw actors below diagram
  bounds.bumpVerticalPos(conf.boxMargin * 2);
  drawActors(diagram, actors, actorKeys, bounds.getVerticalPos());
}

var box = bounds.getBounds();

// Adjust line height of actor lines now that the height of the diagram is known
_logger.logger.debug('For line height fix Querying: #' + id + ' .actor-line');
var actorLines = _d2.default.selectAll('#' + id + ' .actor-line');
actorLines.attr('y2', box.stopy);

var height = box.stopy - box.starty + 2 * conf.diagramMarginY;

if (conf.mirrorActors) {
  height = height - conf.boxMargin + conf.bottomMarginAdj;
}

var width = box.stopx - box.startx + 2 * conf.diagramMarginX;

if (title) {
  diagram.append('text').text(title).attr('x', (box.stopx - box.startx) / 2 - 2 * conf.diagramMarginX).attr('y', -25);
}

if (conf.useMaxWidth) {
  diagram.attr('height', '100%');
  diagram.attr('width', '100%');
  diagram.attr('style', 'max-width:' + width + 'px;');
} else {
  diagram.attr('height', height);
  diagram.attr('width', width);
}
var extraVertForTitle = title ? 40 : 0;
diagram.attr('viewBox', box.startx - conf.diagramMarginX + ' -' + (conf.diagramMarginY + extraVertForTitle) + ' ' + width + ' ' + (height + extraVertForTitle));

};

exports.default = {

bounds: bounds,
drawActors: drawActors,
setConf: setConf,
draw: draw

};

/***/ }), /* 218 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); var drawRect = exports.drawRect = function drawRect(elem, rectData) {

var rectElem = elem.append('rect');
rectElem.attr('x', rectData.x);
rectElem.attr('y', rectData.y);
rectElem.attr('fill', rectData.fill);
rectElem.attr('stroke', rectData.stroke);
rectElem.attr('width', rectData.width);
rectElem.attr('height', rectData.height);
rectElem.attr('rx', rectData.rx);
rectElem.attr('ry', rectData.ry);

if (typeof rectData.class !== 'undefined') {
  rectElem.attr('class', rectData.class);
}

return rectElem;

};

var drawText = exports.drawText = function drawText(elem, textData, width) {

// Remove and ignore br:s
var nText = textData.text.replace(/<br\/?>/ig, ' ');

var textElem = elem.append('text');
textElem.attr('x', textData.x);
textElem.attr('y', textData.y);
textElem.style('text-anchor', textData.anchor);
textElem.attr('fill', textData.fill);
if (typeof textData.class !== 'undefined') {
  textElem.attr('class', textData.class);
}

var span = textElem.append('tspan');
span.attr('x', textData.x + textData.textMargin * 2);
span.attr('fill', textData.fill);
span.text(nText);
if (typeof textElem.textwrap !== 'undefined') {
  textElem.textwrap({
    x: textData.x, // bounding box is 300 pixels from the left
    y: textData.y, // bounding box is 400 pixels from the top
    width: width, // bounding box is 500 pixels across
    height: 1800 // bounding box is 600 pixels tall
  }, textData.textMargin);
}

return textElem;

};

var drawLabel = exports.drawLabel = function drawLabel(elem, txtObject) {

function genPoints(x, y, width, height, cut) {
  return x + ',' + y + ' ' + (x + width) + ',' + y + ' ' + (x + width) + ',' + (y + height - cut) + ' ' + (x + width - cut * 1.2) + ',' + (y + height) + ' ' + x + ',' + (y + height);
}
var polygon = elem.append('polygon');
polygon.attr('points', genPoints(txtObject.x, txtObject.y, 50, 20, 7));
polygon.attr('class', 'labelBox');

txtObject.y = txtObject.y + txtObject.labelMargin;
txtObject.x = txtObject.x + 0.5 * txtObject.labelMargin;
drawText(elem, txtObject);

}; var actorCnt = -1; /**

* Draws an actor in the diagram with the attaced line
* @param center - The center of the the actor
* @param pos The position if the actor in the liost of actors
* @param description The text in the box
*/

var drawActor = exports.drawActor = function drawActor(elem, left, verticalPos, description, conf) {

var center = left + conf.width / 2;
var g = elem.append('g');
if (verticalPos === 0) {
  actorCnt++;
  g.append('line').attr('id', 'actor' + actorCnt).attr('x1', center).attr('y1', 5).attr('x2', center).attr('y2', 2000).attr('class', 'actor-line').attr('stroke-width', '0.5px').attr('stroke', '#999');
}

var rect = getNoteRect();
rect.x = left;
rect.y = verticalPos;
rect.fill = '#eaeaea';
rect.width = conf.width;
rect.height = conf.height;
rect.class = 'actor';
rect.rx = 3;
rect.ry = 3;
drawRect(g, rect);

_drawTextCandidateFunc(conf)(description, g, rect.x, rect.y, rect.width, rect.height, { 'class': 'actor' });

};

var anchorElement = exports.anchorElement = function anchorElement(elem) {

return elem.append('g');

}; /**

* Draws an actor in the diagram with the attaced line
* @param elem - element to append activation rect
* @param bounds - activation box bounds
* @param verticalPos - precise y cooridnate of bottom activation box edge
*/

var drawActivation = exports.drawActivation = function drawActivation(elem, bounds, verticalPos) {

var rect = getNoteRect();
var g = bounds.anchored;
rect.x = bounds.startx;
rect.y = bounds.starty;
rect.fill = '#f4f4f4';
rect.width = bounds.stopx - bounds.startx;
rect.height = verticalPos - bounds.starty;
drawRect(g, rect);

};

/**

* Draws an actor in the diagram with the attaced line
* @param center - The center of the the actor
* @param pos The position if the actor in the list of actors
* @param description The text in the box
*/

var drawLoop = exports.drawLoop = function drawLoop(elem, bounds, labelText, conf) {

var g = elem.append('g');
var drawLoopLine = function drawLoopLine(startx, starty, stopx, stopy) {
  return g.append('line').attr('x1', startx).attr('y1', starty).attr('x2', stopx).attr('y2', stopy).attr('class', 'loopLine');
};
drawLoopLine(bounds.startx, bounds.starty, bounds.stopx, bounds.starty);
drawLoopLine(bounds.stopx, bounds.starty, bounds.stopx, bounds.stopy);
drawLoopLine(bounds.startx, bounds.stopy, bounds.stopx, bounds.stopy);
drawLoopLine(bounds.startx, bounds.starty, bounds.startx, bounds.stopy);
if (typeof bounds.sections !== 'undefined') {
  bounds.sections.forEach(function (item) {
    drawLoopLine(bounds.startx, item, bounds.stopx, item).style('stroke-dasharray', '3, 3');
  });
}

var txt = getTextObj();
txt.text = labelText;
txt.x = bounds.startx;
txt.y = bounds.starty;
txt.labelMargin = 1.5 * 10; // This is the small box that says "loop"
txt.class = 'labelText'; // Its size & position are fixed.

drawLabel(g, txt);

txt = getTextObj();
txt.text = '[ ' + bounds.title + ' ]';
txt.x = bounds.startx + (bounds.stopx - bounds.startx) / 2;
txt.y = bounds.starty + 1.5 * conf.boxMargin;
txt.anchor = 'middle';
txt.class = 'loopText';

drawText(g, txt);

if (typeof bounds.sectionTitles !== 'undefined') {
  bounds.sectionTitles.forEach(function (item, idx) {
    if (item !== '') {
      txt.text = '[ ' + item + ' ]';
      txt.y = bounds.sections[idx] + 1.5 * conf.boxMargin;
      drawText(g, txt);
    }
  });
}

};

/**

* Setup arrow head and define the marker. The result is appended to the svg.
*/

var insertArrowHead = exports.insertArrowHead = function insertArrowHead(elem) {

elem.append('defs').append('marker').attr('id', 'arrowhead').attr('refX', 5).attr('refY', 2).attr('markerWidth', 6).attr('markerHeight', 4).attr('orient', 'auto').append('path').attr('d', 'M 0,0 V 4 L6,2 Z'); // this is actual shape for arrowhead

}; /**

* Setup arrow head and define the marker. The result is appended to the svg.
*/

var insertArrowCrossHead = exports.insertArrowCrossHead = function insertArrowCrossHead(elem) {

var defs = elem.append('defs');
var marker = defs.append('marker').attr('id', 'crosshead').attr('markerWidth', 15).attr('markerHeight', 8).attr('orient', 'auto').attr('refX', 16).attr('refY', 4);

// The arrow
marker.append('path').attr('fill', 'black').attr('stroke', '#000000').style('stroke-dasharray', '0, 0').attr('stroke-width', '1px').attr('d', 'M 9,2 V 6 L16,4 Z');

// The cross
marker.append('path').attr('fill', 'none').attr('stroke', '#000000').style('stroke-dasharray', '0, 0').attr('stroke-width', '1px').attr('d', 'M 0,1 L 6,7 M 6,1 L 0,7');
// this is actual shape for arrowhead

};

var getTextObj = exports.getTextObj = function getTextObj() {

var txt = {
  x: 0,
  y: 0,
  'fill': 'black',
  'text-anchor': 'start',
  style: '#666',
  width: 100,
  height: 100,
  textMargin: 0,
  rx: 0,
  ry: 0
};
return txt;

};

var getNoteRect = exports.getNoteRect = function getNoteRect() {

var rect = {
  x: 0,
  y: 0,
  fill: '#EDF2AE',
  stroke: '#666',
  width: 100,
  anchor: 'start',
  height: 100,
  rx: 0,
  ry: 0
};
return rect;

};

var _drawTextCandidateFunc = function () {

function byText(content, g, x, y, width, height, textAttrs) {
  var text = g.append('text').attr('x', x + width / 2).attr('y', y + height / 2 + 5).style('text-anchor', 'middle').text(content);
  _setTextAttrs(text, textAttrs);
}

function byTspan(content, g, x, y, width, height, textAttrs) {
  var text = g.append('text').attr('x', x + width / 2).attr('y', y).style('text-anchor', 'middle');
  text.append('tspan').attr('x', x + width / 2).attr('dy', '0').text(content);

  if (typeof text.textwrap !== 'undefined') {
    text.textwrap({ // d3textwrap
      x: x + width / 2, y: y, width: width, height: height
    }, 0);
    // vertical aligment after d3textwrap expans tspan to multiple tspans
    var tspans = text.selectAll('tspan');
    if (tspans.length > 0 && tspans[0].length > 0) {
      tspans = tspans[0];
      // set y of <text> to the mid y of the first line
      text.attr('y', y + (height / 2.0 - text[0][0].getBBox().height * (1 - 1.0 / tspans.length) / 2.0)).attr('dominant-baseline', 'central').attr('alignment-baseline', 'central');
    }
  }
  _setTextAttrs(text, textAttrs);
}

function byFo(content, g, x, y, width, height, textAttrs) {
  var s = g.append('switch');
  var f = s.append('foreignObject').attr('x', x).attr('y', y).attr('width', width).attr('height', height);

  var text = f.append('div').style('display', 'table').style('height', '100%').style('width', '100%');

  text.append('div').style('display', 'table-cell').style('text-align', 'center').style('vertical-align', 'middle').text(content);

  byTspan(content, s, x, y, width, height, textAttrs);
  _setTextAttrs(text, textAttrs);
}

function _setTextAttrs(toText, fromTextAttrsDict) {
  for (var key in fromTextAttrsDict) {
    if (fromTextAttrsDict.hasOwnProperty(key)) {
      toText.attr(key, fromTextAttrsDict[key]);
    }
  }
}

return function (conf) {
  return conf.textPlacement === 'fo' ? byFo : conf.textPlacement === 'old' ? byText : byTspan;
};

}();

exports.default = {

drawRect: drawRect,
drawText: drawText,
drawLabel: drawLabel,
drawActor: drawActor,
anchorElement: anchorElement,
drawActivation: drawActivation,
drawLoop: drawLoop,
insertArrowHead: insertArrowHead,
insertArrowCrossHead: insertArrowCrossHead,
getTextObj: getTextObj,
getNoteRect: getNoteRect

};

/***/ }), /* 219 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.draw = undefined;

var _exampleDb = webpack_require(165);

var _exampleDb2 = _interopRequireDefault(_exampleDb);

var _example = webpack_require(166);

var _example2 = _interopRequireDefault(_example);

var _d = webpack_require(6);

var _d2 = _interopRequireDefault(_d);

var _logger = webpack_require(1);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**

* Draws a an info picture in the tag with id: id based on the graph definition in text.
* @param text
* @param id
*/

var draw = exports.draw = function draw(txt, id, ver) {

var parser;
parser = _example2.default.parser;
parser.yy = _exampleDb2.default;
_logger.logger.debug('Renering example diagram');
// Parse the graph definition
parser.parse(txt);

// Fetch the default direction, use TD if none was found
var svg = _d2.default.select('#' + id);

var g = svg.append('g');

g.append('text') // text label for the x axis
.attr('x', 100).attr('y', 40).attr('class', 'version').attr('font-size', '32px').style('text-anchor', 'middle').text('mermaid ' + ver);

svg.attr('height', 100);
svg.attr('width', 400);

};

exports.default = {

draw: draw

};

/***/ }), /* 220 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.draw = exports.setConf = undefined;

var _moment = webpack_require(0);

var _moment2 = _interopRequireDefault(_moment);

var _gantt = webpack_require(167);

var _ganttDb = webpack_require(168);

var _ganttDb2 = _interopRequireDefault(_ganttDb);

var _d = webpack_require(6);

var _d2 = _interopRequireDefault(_d);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_gantt.parser.yy = _ganttDb2.default;

var daysInChart; var conf = {

titleTopMargin: 25,
barHeight: 20,
barGap: 4,
topPadding: 50,
rightPadding: 75,
leftPadding: 75,
gridLineStartPadding: 35,
fontSize: 11,
fontFamily: '"Open-Sans", "sans-serif"'

}; var setConf = exports.setConf = function setConf(cnf) {

var keys = Object.keys(cnf);

keys.forEach(function (key) {
  conf[key] = cnf[key];
});

}; var w; var draw = exports.draw = function draw(text, id) {

_gantt.parser.yy.clear();
_gantt.parser.parse(text);

var elem = document.getElementById(id);
w = elem.parentElement.offsetWidth;

if (typeof w === 'undefined') {
  w = 1200;
}

if (typeof conf.useWidth !== 'undefined') {
  w = conf.useWidth;
}

var taskArray = _gantt.parser.yy.getTasks();

// Set height based on number of tasks
var h = taskArray.length * (conf.barHeight + conf.barGap) + 2 * conf.topPadding;

elem.setAttribute('height', '100%');
// Set viewBox
elem.setAttribute('viewBox', '0 0 ' + w + ' ' + h);
var svg = _d2.default.select('#' + id);

var startDate = _d2.default.min(taskArray, function (d) {
  return d.startTime;
});
var endDate = _d2.default.max(taskArray, function (d) {
  return d.endTime;
});

// Set timescale
var timeScale = _d2.default.time.scale().domain([_d2.default.min(taskArray, function (d) {
  return d.startTime;
}), _d2.default.max(taskArray, function (d) {
  return d.endTime;
})]).rangeRound([0, w - conf.leftPadding - conf.rightPadding]);

var categories = [];

daysInChart = _moment2.default.duration(endDate - startDate).asDays();

for (var i = 0; i < taskArray.length; i++) {
  categories.push(taskArray[i].type);
}

var catsUnfiltered = categories; // for vert labels

categories = checkUnique(categories);

makeGant(taskArray, w, h);
if (typeof conf.useWidth !== 'undefined') {
  elem.setAttribute('width', w);
}

svg.append('text').text(_gantt.parser.yy.getTitle()).attr('x', w / 2).attr('y', conf.titleTopMargin).attr('class', 'titleText');

function makeGant(tasks, pageWidth, pageHeight) {
  var barHeight = conf.barHeight;
  var gap = barHeight + conf.barGap;
  var topPadding = conf.topPadding;
  var leftPadding = conf.leftPadding;

  var colorScale = _d2.default.scale.linear().domain([0, categories.length]).range(['#00B9FA', '#F95002']).interpolate(_d2.default.interpolateHcl);

  makeGrid(leftPadding, topPadding, pageWidth, pageHeight);
  drawRects(tasks, gap, topPadding, leftPadding, barHeight, colorScale, pageWidth, pageHeight);
  vertLabels(gap, topPadding, leftPadding, barHeight, colorScale);
  drawToday(leftPadding, topPadding, pageWidth, pageHeight);
}

function drawRects(theArray, theGap, theTopPad, theSidePad, theBarHeight, theColorScale, w, h) {
  svg.append('g').selectAll('rect').data(theArray).enter().append('rect').attr('x', 0).attr('y', function (d, i) {
    return i * theGap + theTopPad - 2;
  }).attr('width', function () {
    return w - conf.rightPadding / 2;
  }).attr('height', theGap).attr('class', function (d) {
    for (var i = 0; i < categories.length; i++) {
      if (d.type === categories[i]) {
        return 'section section' + i % conf.numberSectionStyles;
      }
    }
    return 'section section0';
  });

  var rectangles = svg.append('g').selectAll('rect').data(theArray).enter();

  rectangles.append('rect').attr('rx', 3).attr('ry', 3).attr('x', function (d) {
    return timeScale(d.startTime) + theSidePad;
  }).attr('y', function (d, i) {
    return i * theGap + theTopPad;
  }).attr('width', function (d) {
    return timeScale(d.endTime) - timeScale(d.startTime);
  }).attr('height', theBarHeight).attr('class', function (d) {
    var res = 'task ';

    var secNum = 0;
    for (var i = 0; i < categories.length; i++) {
      if (d.type === categories[i]) {
        secNum = i % conf.numberSectionStyles;
      }
    }

    if (d.active) {
      if (d.crit) {
        return res + ' activeCrit' + secNum;
      } else {
        return res + ' active' + secNum;
      }
    }

    if (d.done) {
      if (d.crit) {
        return res + ' doneCrit' + secNum;
      } else {
        return res + ' done' + secNum;
      }
    }

    if (d.crit) {
      return res + ' crit' + secNum;
    }

    return res + ' task' + secNum;
  });

  rectangles.append('text').text(function (d) {
    return d.task;
  }).attr('font-size', conf.fontSize).attr('x', function (d) {
    var startX = timeScale(d.startTime);
    var endX = timeScale(d.endTime);
    var textWidth = this.getBBox().width;

    // Check id text width > width of rectangle
    if (textWidth > endX - startX) {
      if (endX + textWidth + 1.5 * conf.leftPadding > w) {
        return startX + theSidePad - 5;
      } else {
        return endX + theSidePad + 5;
      }
    } else {
      return (endX - startX) / 2 + startX + theSidePad;
    }
  }).attr('y', function (d, i) {
    return i * theGap + conf.barHeight / 2 + (conf.fontSize / 2 - 2) + theTopPad;
  }).attr('text-height', theBarHeight).attr('class', function (d) {
    var startX = timeScale(d.startTime);
    var endX = timeScale(d.endTime);
    var textWidth = this.getBBox().width;
    var secNum = 0;
    for (var i = 0; i < categories.length; i++) {
      if (d.type === categories[i]) {
        secNum = i % conf.numberSectionStyles;
      }
    }

    var taskType = '';
    if (d.active) {
      if (d.crit) {
        taskType = 'activeCritText' + secNum;
      } else {
        taskType = 'activeText' + secNum;
      }
    }

    if (d.done) {
      if (d.crit) {
        taskType = taskType + ' doneCritText' + secNum;
      } else {
        taskType = taskType + ' doneText' + secNum;
      }
    } else {
      if (d.crit) {
        taskType = taskType + ' critText' + secNum;
      }
    }

    // Check id text width > width of rectangle
    if (textWidth > endX - startX) {
      if (endX + textWidth + 1.5 * conf.leftPadding > w) {
        return 'taskTextOutsideLeft taskTextOutside' + secNum + ' ' + taskType;
      } else {
        return 'taskTextOutsideRight taskTextOutside' + secNum + ' ' + taskType;
      }
    } else {
      return 'taskText taskText' + secNum + ' ' + taskType;
    }
  });
}

function makeGrid(theSidePad, theTopPad, w, h) {
  var pre = [['.%L', function (d) {
    return d.getMilliseconds();
  }], [':%S', function (d) {
    return d.getSeconds();
  }],
  // Within a hour
  ['h1 %I:%M', function (d) {
    return d.getMinutes();
  }]];
  var post = [['%Y', function () {
    return true;
  }]];

  var mid = [
  // Within a day
  ['%I:%M', function (d) {
    return d.getHours();
  }],
  // Day within a week (not monday)
  ['%a %d', function (d) {
    return d.getDay() && d.getDate() !== 1;
  }],
  // within a month
  ['%b %d', function (d) {
    return d.getDate() !== 1;
  }],
  // Month
  ['%B', function (d) {
    return d.getMonth();
  }]];
  var formatter;
  if (typeof conf.axisFormatter !== 'undefined') {
    mid = [];
    conf.axisFormatter.forEach(function (item) {
      var n = [];
      n[0] = item[0];
      n[1] = item[1];
      mid.push(n);
    });
  }
  formatter = pre.concat(mid).concat(post);

  var xAxis = _d2.default.svg.axis().scale(timeScale).orient('bottom').tickSize(-h + theTopPad + conf.gridLineStartPadding, 0, 0).tickFormat(_d2.default.time.format.multi(formatter));

  if (daysInChart > 7 && daysInChart < 230) {
    xAxis = xAxis.ticks(_d2.default.time.monday.range);
  }

  svg.append('g').attr('class', 'grid').attr('transform', 'translate(' + theSidePad + ', ' + (h - 50) + ')').call(xAxis).selectAll('text').style('text-anchor', 'middle').attr('fill', '#000').attr('stroke', 'none').attr('font-size', 10).attr('dy', '1em');
}

function vertLabels(theGap, theTopPad) {
  var numOccurances = [];
  var prevGap = 0;

  for (var i = 0; i < categories.length; i++) {
    numOccurances[i] = [categories[i], getCount(categories[i], catsUnfiltered)];
  }

  svg.append('g') // without doing this, impossible to put grid lines behind text
  .selectAll('text').data(numOccurances).enter().append('text').text(function (d) {
    return d[0];
  }).attr('x', 10).attr('y', function (d, i) {
    if (i > 0) {
      for (var j = 0; j < i; j++) {
        prevGap += numOccurances[i - 1][1];
        return d[1] * theGap / 2 + prevGap * theGap + theTopPad;
      }
    } else {
      return d[1] * theGap / 2 + theTopPad;
    }
  }).attr('class', function (d) {
    for (var i = 0; i < categories.length; i++) {
      if (d[0] === categories[i]) {
        return 'sectionTitle sectionTitle' + i % conf.numberSectionStyles;
      }
    }
    return 'sectionTitle';
  });
}

function drawToday(theSidePad, theTopPad, w, h) {
  var todayG = svg.append('g').attr('class', 'today');

  var today = new Date();

  todayG.append('line').attr('x1', timeScale(today) + theSidePad).attr('x2', timeScale(today) + theSidePad).attr('y1', conf.titleTopMargin).attr('y2', h - conf.titleTopMargin).attr('class', 'today');
}

// from this stackexchange question: http://stackoverflow.com/questions/1890203/unique-for-arrays-in-javascript
function checkUnique(arr) {
  var hash = {};
  var result = [];
  for (var i = 0, l = arr.length; i < l; ++i) {
    if (!hash.hasOwnProperty(arr[i])) {
      // it works with objects! in FF, at least
      hash[arr[i]] = true;
      result.push(arr[i]);
    }
  }
  return result;
}

// from this stackexchange question: http://stackoverflow.com/questions/14227981/count-how-many-strings-in-an-array-have-duplicates-in-the-same-array
function getCounts(arr) {
  var i = arr.length; // var to loop over
  var obj = {}; // obj to store results
  while (i) {
    obj[arr[--i]] = (obj[arr[i]] || 0) + 1; // count occurrences
  }
  return obj;
}

// get specific from everything
function getCount(word, arr) {
  return getCounts(arr)[word] || 0;
}

};

exports.default = {

setConf: setConf,
draw: draw

};

/***/ }), /* 221 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.draw = exports.setConf = undefined;

var _dagreLayout = webpack_require(30);

var _dagreLayout2 = _interopRequireDefault(_dagreLayout);

var _classDb = webpack_require(170);

var _classDb2 = _interopRequireDefault(_classDb);

var _d = webpack_require(6);

var _d2 = _interopRequireDefault(_d);

var _logger = webpack_require(1);

var _classDiagram = webpack_require(169);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_classDiagram.parser.yy = _classDb2.default;

var idCache; idCache = {};

var classCnt = 0; var conf = {

dividerMargin: 10,
padding: 5,
textHeight: 10

// Todo optimize

};var getGraphId = function getGraphId(label) {

var keys = Object.keys(idCache);

var i;
for (i = 0; i < keys.length; i++) {
  if (idCache[keys[i]].label === label) {
    return keys[i];
  }
}

return undefined;

};

/**

* Setup arrow head and define the marker. The result is appended to the svg.
*/

var insertMarkers = function insertMarkers(elem) {

elem.append('defs').append('marker').attr('id', 'extensionStart').attr('class', 'extension').attr('refX', 0).attr('refY', 7).attr('markerWidth', 190).attr('markerHeight', 240).attr('orient', 'auto').append('path').attr('d', 'M 1,7 L18,13 V 1 Z');

elem.append('defs').append('marker').attr('id', 'extensionEnd').attr('refX', 19).attr('refY', 7).attr('markerWidth', 20).attr('markerHeight', 28).attr('orient', 'auto').append('path').attr('d', 'M 1,1 V 13 L18,7 Z'); // this is actual shape for arrowhead

elem.append('defs').append('marker').attr('id', 'compositionStart').attr('class', 'extension').attr('refX', 0).attr('refY', 7).attr('markerWidth', 190).attr('markerHeight', 240).attr('orient', 'auto').append('path').attr('d', 'M 18,7 L9,13 L1,7 L9,1 Z');

elem.append('defs').append('marker').attr('id', 'compositionEnd').attr('refX', 19).attr('refY', 7).attr('markerWidth', 20).attr('markerHeight', 28).attr('orient', 'auto').append('path').attr('d', 'M 18,7 L9,13 L1,7 L9,1 Z');

elem.append('defs').append('marker').attr('id', 'aggregationStart').attr('class', 'extension').attr('refX', 0).attr('refY', 7).attr('markerWidth', 190).attr('markerHeight', 240).attr('orient', 'auto').append('path').attr('d', 'M 18,7 L9,13 L1,7 L9,1 Z');

elem.append('defs').append('marker').attr('id', 'aggregationEnd').attr('refX', 19).attr('refY', 7).attr('markerWidth', 20).attr('markerHeight', 28).attr('orient', 'auto').append('path').attr('d', 'M 18,7 L9,13 L1,7 L9,1 Z');

elem.append('defs').append('marker').attr('id', 'dependencyStart').attr('class', 'extension').attr('refX', 0).attr('refY', 7).attr('markerWidth', 190).attr('markerHeight', 240).attr('orient', 'auto').append('path').attr('d', 'M 5,7 L9,13 L1,7 L9,1 Z');

elem.append('defs').append('marker').attr('id', 'dependencyEnd').attr('refX', 19).attr('refY', 7).attr('markerWidth', 20).attr('markerHeight', 28).attr('orient', 'auto').append('path').attr('d', 'M 18,7 L9,13 L14,7 L9,1 Z');

};

var edgeCount = 0; var drawEdge = function drawEdge(elem, path, relation) {

var getRelationType = function getRelationType(type) {
  switch (type) {
    case _classDb2.default.relationType.AGGREGATION:
      return 'aggregation';
    case _classDb2.default.relationType.EXTENSION:
      return 'extension';
    case _classDb2.default.relationType.COMPOSITION:
      return 'composition';
    case _classDb2.default.relationType.DEPENDENCY:
      return 'dependency';
  }
};

// The data for our line
var lineData = path.points;

// This is the accessor function we talked about above
var lineFunction = _d2.default.svg.line().x(function (d) {
  return d.x;
}).y(function (d) {
  return d.y;
}).interpolate('basis');

var svgPath = elem.append('path').attr('d', lineFunction(lineData)).attr('id', 'edge' + edgeCount).attr('class', 'relation');
var url = '';
if (conf.arrowMarkerAbsolute) {
  url = window.location.protocol + '//' + window.location.host + window.location.pathname + window.location.search;
  url = url.replace(/\(/g, '\\(');
  url = url.replace(/\)/g, '\\)');
}

if (relation.relation.type1 !== 'none') {
  svgPath.attr('marker-start', 'url(' + url + '#' + getRelationType(relation.relation.type1) + 'Start' + ')');
}
if (relation.relation.type2 !== 'none') {
  svgPath.attr('marker-end', 'url(' + url + '#' + getRelationType(relation.relation.type2) + 'End' + ')');
}

var x, y;
var l = path.points.length;
if (l % 2 !== 0) {
  var p1 = path.points[Math.floor(l / 2)];
  var p2 = path.points[Math.ceil(l / 2)];
  x = (p1.x + p2.x) / 2;
  y = (p1.y + p2.y) / 2;
} else {
  var p = path.points[Math.floor(l / 2)];
  x = p.x;
  y = p.y;
}

if (typeof relation.title !== 'undefined') {
  var g = elem.append('g').attr('class', 'classLabel');
  var label = g.append('text').attr('class', 'label').attr('x', x).attr('y', y).attr('fill', 'red').attr('text-anchor', 'middle').text(relation.title);

  window.label = label;
  var bounds = label.node().getBBox();

  g.insert('rect', ':first-child').attr('class', 'box').attr('x', bounds.x - conf.padding / 2).attr('y', bounds.y - conf.padding / 2).attr('width', bounds.width + conf.padding).attr('height', bounds.height + conf.padding);
}

edgeCount++;

};

var drawClass = function drawClass(elem, classDef) {

_logger.logger.info('Rendering class ' + classDef);

var addTspan = function addTspan(textEl, txt, isFirst) {
  var tSpan = textEl.append('tspan').attr('x', conf.padding).text(txt);
  if (!isFirst) {
    tSpan.attr('dy', conf.textHeight);
  }
};

var id = 'classId' + classCnt;
var classInfo = {
  id: id,
  label: classDef.id,
  width: 0,
  height: 0
};

var g = elem.append('g').attr('id', id).attr('class', 'classGroup');
var title = g.append('text').attr('x', conf.padding).attr('y', conf.textHeight + conf.padding).text(classDef.id);

var titleHeight = title.node().getBBox().height;

var membersLine = g.append('line') // text label for the x axis
.attr('x1', 0).attr('y1', conf.padding + titleHeight + conf.dividerMargin / 2).attr('y2', conf.padding + titleHeight + conf.dividerMargin / 2);

var members = g.append('text') // text label for the x axis
.attr('x', conf.padding).attr('y', titleHeight + conf.dividerMargin + conf.textHeight).attr('fill', 'white').attr('class', 'classText');

var isFirst = true;

classDef.members.forEach(function (member) {
  addTspan(members, member, isFirst);
  isFirst = false;
});

var membersBox = members.node().getBBox();

var methodsLine = g.append('line') // text label for the x axis
.attr('x1', 0).attr('y1', conf.padding + titleHeight + conf.dividerMargin + membersBox.height).attr('y2', conf.padding + titleHeight + conf.dividerMargin + membersBox.height);

var methods = g.append('text') // text label for the x axis
.attr('x', conf.padding).attr('y', titleHeight + 2 * conf.dividerMargin + membersBox.height + conf.textHeight).attr('fill', 'white').attr('class', 'classText');

isFirst = true;

classDef.methods.forEach(function (method) {
  addTspan(methods, method, isFirst);
  isFirst = false;
});

var classBox = g.node().getBBox();
g.insert('rect', ':first-child').attr('x', 0).attr('y', 0).attr('width', classBox.width + 2 * conf.padding).attr('height', classBox.height + conf.padding + 0.5 * conf.dividerMargin);

membersLine.attr('x2', classBox.width + 2 * conf.padding);
methodsLine.attr('x2', classBox.width + 2 * conf.padding);

classInfo.width = classBox.width + 2 * conf.padding;
classInfo.height = classBox.height + conf.padding + 0.5 * conf.dividerMargin;

idCache[id] = classInfo;
classCnt++;
return classInfo;

};

var setConf = exports.setConf = function setConf(cnf) {

var keys = Object.keys(cnf);

keys.forEach(function (key) {
  conf[key] = cnf[key];
});

}; /**

* Draws a flowchart in the tag with id: id based on the graph definition in text.
* @param text
* @param id
*/

var draw = exports.draw = function draw(text, id) {

_classDiagram.parser.yy.clear();
_classDiagram.parser.parse(text);

_logger.logger.info('Rendering diagram ' + text);

/// / Fetch the default direction, use TD if none was found
var diagram = _d2.default.select('#' + id);
insertMarkers(diagram);

// Layout graph, Create a new directed graph
var g = new _dagreLayout2.default.graphlib.Graph({
  multigraph: true
});

// Set an object for the graph label
g.setGraph({
  isMultiGraph: true
});

// Default to assigning a new object as a label for each new edge.
g.setDefaultEdgeLabel(function () {
  return {};
});

var classes = _classDb2.default.getClasses();
var keys = Object.keys(classes);
var i;
for (i = 0; i < keys.length; i++) {
  var classDef = classes[keys[i]];
  var node = drawClass(diagram, classDef);
  // Add nodes to the graph. The first argument is the node id. The second is
  // metadata about the node. In this case we're going to add labels to each of
  // our nodes.
  g.setNode(node.id, node);
  _logger.logger.info('Org height: ' + node.height);
}

var relations = _classDb2.default.getRelations();
relations.forEach(function (relation) {
  _logger.logger.info('tjoho' + getGraphId(relation.id1) + getGraphId(relation.id2) + JSON.stringify(relation));
  g.setEdge(getGraphId(relation.id1), getGraphId(relation.id2), { relation: relation });
});
_dagreLayout2.default.layout(g);
g.nodes().forEach(function (v) {
  if (typeof v !== 'undefined') {
    _logger.logger.debug('Node ' + v + ': ' + JSON.stringify(g.node(v)));
    _d2.default.select('#' + v).attr('transform', 'translate(' + (g.node(v).x - g.node(v).width / 2) + ',' + (g.node(v).y - g.node(v).height / 2) + ' )');
  }
});
g.edges().forEach(function (e) {
  _logger.logger.debug('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(g.edge(e)));
  drawEdge(diagram, g.edge(e), g.edge(e).relation);
});

diagram.attr('height', '100%');
diagram.attr('width', '100%');
diagram.attr('viewBox', '0 0 ' + (g.graph().width + 20) + ' ' + (g.graph().height + 20));

};

exports.default = {

setConf: setConf,
draw: draw

};

/***/ }), /* 222 */ /***/ (function(module, exports, webpack_require) {

“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.draw = exports.setConf = undefined;

var _each2 = webpack_require(172);

var _each3 = _interopRequireDefault(_each2);

var _extend2 = webpack_require(240);

var _extend3 = _interopRequireDefault(_extend2);

var _isArray2 = webpack_require(2);

var _isArray3 = _interopRequireDefault(_isArray2);

var _find2 = webpack_require(260);

var _find3 = _interopRequireDefault(_find2);

var _isString2 = webpack_require(322);

var _isString3 = _interopRequireDefault(_isString2);

var _gitGraphAst = webpack_require(196);

var _gitGraphAst2 = _interopRequireDefault(_gitGraphAst);

var _gitGraph = webpack_require(171);

var _gitGraph2 = _interopRequireDefault(_gitGraph);

var _d = webpack_require(6);

var _d2 = _interopRequireDefault(_d);

var _logger = webpack_require(1);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var allCommitsDict = {}; var branchNum; var config = {

nodeSpacing: 150,
nodeFillColor: 'yellow',
nodeStrokeWidth: 2,
nodeStrokeColor: 'grey',
lineStrokeWidth: 4,
branchOffset: 50,
lineColor: 'grey',
leftMargin: 50,
branchColors: ['#442f74', '#983351', '#609732', '#AA9A39'],
nodeRadius: 10,
nodeLabel: {
  width: 75,
  height: 100,
  x: -25,
  y: 0
}

}; var apiConfig = {}; var setConf = exports.setConf = function setConf© {

apiConfig = c;

};

function svgCreateDefs(svg) {

svg.append('defs').append('g').attr('id', 'def-commit').append('circle').attr('r', config.nodeRadius).attr('cx', 0).attr('cy', 0);
svg.select('#def-commit').append('foreignObject').attr('width', config.nodeLabel.width).attr('height', config.nodeLabel.height).attr('x', config.nodeLabel.x).attr('y', config.nodeLabel.y).attr('class', 'node-label').attr('requiredFeatures', 'http://www.w3.org/TR/SVG11/feature#Extensibility').append('xhtml:p').html('');

}

function svgDrawLine(svg, points, colorIdx, interpolate) {

interpolate = interpolate || 'basis';
var color = config.branchColors[colorIdx % config.branchColors.length];
var lineGen = _d2.default.svg.line().x(function (d) {
  return Math.round(d.x);
}).y(function (d) {
  return Math.round(d.y);
}).interpolate(interpolate);

svg.append('svg:path').attr('d', lineGen(points)).style('stroke', color).style('stroke-width', config.lineStrokeWidth).style('fill', 'none');

} // Pass in the element and its pre-transform coords function getElementCoords(element, coords) {

coords = coords || element.node().getBBox();
var ctm = element.node().getCTM();
var xn = ctm.e + coords.x * ctm.a;
var yn = ctm.f + coords.y * ctm.d;
return {
  left: xn,
  top: yn,
  width: coords.width,
  height: coords.height
};

}

function svgDrawLineForCommits(svg, fromId, toId, direction, color) {

_logger.logger.debug('svgDrawLineForCommits: ', fromId, toId);
var fromBbox = getElementCoords(svg.select('#node-' + fromId + ' circle'));
var toBbox = getElementCoords(svg.select('#node-' + toId + ' circle'));
switch (direction) {
  case 'LR':
    // (toBbox)
    //  +--------
    //          + (fromBbox)
    if (fromBbox.left - toBbox.left > config.nodeSpacing) {
      var lineStart = { x: fromBbox.left - config.nodeSpacing, y: toBbox.top + toBbox.height / 2 };
      var lineEnd = { x: toBbox.left + toBbox.width, y: toBbox.top + toBbox.height / 2 };
      svgDrawLine(svg, [lineStart, lineEnd], color, 'linear');
      svgDrawLine(svg, [{ x: fromBbox.left, y: fromBbox.top + fromBbox.height / 2 }, { x: fromBbox.left - config.nodeSpacing / 2, y: fromBbox.top + fromBbox.height / 2 }, { x: fromBbox.left - config.nodeSpacing / 2, y: lineStart.y }, lineStart], color);
    } else {
      svgDrawLine(svg, [{
        'x': fromBbox.left,
        'y': fromBbox.top + fromBbox.height / 2
      }, {
        'x': fromBbox.left - config.nodeSpacing / 2,
        'y': fromBbox.top + fromBbox.height / 2
      }, {
        'x': fromBbox.left - config.nodeSpacing / 2,
        'y': toBbox.top + toBbox.height / 2
      }, {
        'x': toBbox.left + toBbox.width,
        'y': toBbox.top + toBbox.height / 2
      }], color);
    }
    break;
  case 'BT':
    //      +           (fromBbox)
    //      |
    //      |
    //              +   (toBbox)
    if (toBbox.top - fromBbox.top > config.nodeSpacing) {
      lineStart = { x: toBbox.left + toBbox.width / 2, y: fromBbox.top + fromBbox.height + config.nodeSpacing };
      lineEnd = { x: toBbox.left + toBbox.width / 2, y: toBbox.top };
      svgDrawLine(svg, [lineStart, lineEnd], color, 'linear');
      svgDrawLine(svg, [{ x: fromBbox.left + fromBbox.width / 2, y: fromBbox.top + fromBbox.height }, { x: fromBbox.left + fromBbox.width / 2, y: fromBbox.top + fromBbox.height + config.nodeSpacing / 2 }, { x: toBbox.left + toBbox.width / 2, y: lineStart.y - config.nodeSpacing / 2 }, lineStart], color);
    } else {
      svgDrawLine(svg, [{
        'x': fromBbox.left + fromBbox.width / 2,
        'y': fromBbox.top + fromBbox.height
      }, {
        'x': fromBbox.left + fromBbox.width / 2,
        'y': fromBbox.top + config.nodeSpacing / 2
      }, {
        'x': toBbox.left + toBbox.width / 2,
        'y': toBbox.top - config.nodeSpacing / 2
      }, {
        'x': toBbox.left + toBbox.width / 2,
        'y': toBbox.top
      }], color);
    }
    break;
}

}

function cloneNode(svg, selector) {

return svg.select(selector).node().cloneNode(true);

}

function renderCommitHistory(svg, commitid, branches, direction) {

var commit;
var numCommits = Object.keys(allCommitsDict).length;
if ((0, _isString3.default)(commitid)) {
  do {
    commit = allCommitsDict[commitid];
    _logger.logger.debug('in renderCommitHistory', commit.id, commit.seq);
    if (svg.select('#node-' + commitid).size() > 0) {
      return;
    }
    svg.append(function () {
      return cloneNode(svg, '#def-commit');
    }).attr('class', 'commit').attr('id', function () {
      return 'node-' + commit.id;
    }).attr('transform', function () {
      switch (direction) {
        case 'LR':
          return 'translate(' + (commit.seq * config.nodeSpacing + config.leftMargin) + ', ' + branchNum * config.branchOffset + ')';
        case 'BT':
          return 'translate(' + (branchNum * config.branchOffset + config.leftMargin) + ', ' + (numCommits - commit.seq) * config.nodeSpacing + ')';
      }
    }).attr('fill', config.nodeFillColor).attr('stroke', config.nodeStrokeColor).attr('stroke-width', config.nodeStrokeWidth);

    var branch = (0, _find3.default)(branches, ['commit', commit]);
    if (branch) {
      _logger.logger.debug('found branch ', branch.name);
      svg.select('#node-' + commit.id + ' p').append('xhtml:span').attr('class', 'branch-label').text(branch.name + ', ');
    }
    svg.select('#node-' + commit.id + ' p').append('xhtml:span').attr('class', 'commit-id').text(commit.id);
    if (commit.message !== '' && direction === 'BT') {
      svg.select('#node-' + commit.id + ' p').append('xhtml:span').attr('class', 'commit-msg').text(', ' + commit.message);
    }
    commitid = commit.parent;
  } while (commitid && allCommitsDict[commitid]);
}

if ((0, _isArray3.default)(commitid)) {
  _logger.logger.debug('found merge commmit', commitid);
  renderCommitHistory(svg, commitid[0], branches, direction);
  branchNum++;
  renderCommitHistory(svg, commitid[1], branches, direction);
  branchNum--;
}

}

function renderLines(svg, commit, direction, branchColor) {

branchColor = branchColor || 0;
while (commit.seq > 0 && !commit.lineDrawn) {
  if ((0, _isString3.default)(commit.parent)) {
    svgDrawLineForCommits(svg, commit.id, commit.parent, direction, branchColor);
    commit.lineDrawn = true;
    commit = allCommitsDict[commit.parent];
  } else if ((0, _isArray3.default)(commit.parent)) {
    svgDrawLineForCommits(svg, commit.id, commit.parent[0], direction, branchColor);
    svgDrawLineForCommits(svg, commit.id, commit.parent[1], direction, branchColor + 1);
    renderLines(svg, allCommitsDict[commit.parent[1]], direction, branchColor + 1);
    commit.lineDrawn = true;
    commit = allCommitsDict[commit.parent[0]];
  }
}

}

var draw = exports.draw = function draw(txt, id, ver) {

try {
  var parser;
  parser = _gitGraph2.default.parser;
  parser.yy = _gitGraphAst2.default;

  _logger.logger.debug('in gitgraph renderer', txt, id, ver);
  // Parse the graph definition
  parser.parse(txt + '\n');

  config = (0, _extend3.default)(config, apiConfig, _gitGraphAst2.default.getOptions());
  _logger.logger.debug('effective options', config);
  var direction = _gitGraphAst2.default.getDirection();
  allCommitsDict = _gitGraphAst2.default.getCommits();
  var branches = _gitGraphAst2.default.getBranchesAsObjArray();
  if (direction === 'BT') {
    config.nodeLabel.x = branches.length * config.branchOffset;
    config.nodeLabel.width = '100%';
    config.nodeLabel.y = -1 * 2 * config.nodeRadius;
  }
  var svg = _d2.default.select('#' + id);
  svgCreateDefs(svg);
  branchNum = 1;
  (0, _each3.default)(branches, function (v) {
    renderCommitHistory(svg, v.commit.id, branches, direction);
    renderLines(svg, v.commit, direction);
    branchNum++;
  });
  svg.attr('height', function () {
    if (direction === 'BT') return Object.keys(allCommitsDict).length * config.nodeSpacing;
    return (branches.length + 1) * config.branchOffset;
  });
} catch (e) {
  _logger.logger.error('Error while rendering gitgraph');
  _logger.logger.error(e.message);
}

};

exports.default = {

setConf: setConf,
draw: draw

};

/***/ }), /* 223 */ /***/ (function(module, exports, webpack_require) {

var arrayEach = webpack_require(224),

baseEach = __webpack_require__(173),
castFunction = __webpack_require__(239),
isArray = __webpack_require__(2);

/**

* Iterates over elements of `collection` and invokes `iteratee` for each element.
* The iteratee is invoked with three arguments: (value, index|key, collection).
* Iteratee functions may exit iteration early by explicitly returning `false`.
*
* **Note:** As with other "Collections" methods, objects with a "length"
* property are iterated like arrays. To avoid this behavior use `_.forIn`
* or `_.forOwn` for object iteration.
*
* @static
* @memberOf _
* @since 0.1.0
* @alias each
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Array|Object} Returns `collection`.
* @see _.forEachRight
* @example
*
* _.forEach([1, 2], function(value) {
*   console.log(value);
* });
* // => Logs `1` then `2`.
*
* _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
*   console.log(key);
* });
* // => Logs 'a' then 'b' (iteration order is not guaranteed).
*/

function forEach(collection, iteratee) {

var func = isArray(collection) ? arrayEach : baseEach;
return func(collection, castFunction(iteratee));

}

module.exports = forEach;

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

/**

* 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 == null ? 0 : array.length;

while (++index < length) {
  if (iteratee(array[index], index, array) === false) {
    break;
  }
}
return array;

}

module.exports = arrayEach;

/***/ }), /* 225 */ /***/ (function(module, exports, webpack_require) {

var baseFor = webpack_require(226),

keys = __webpack_require__(21);

/**

* The base implementation of `_.forOwn` without support for iteratee shorthands.
*
* @private
* @param {Object} object The object to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Object} Returns `object`.
*/

function baseForOwn(object, iteratee) {

return object && baseFor(object, iteratee, keys);

}

module.exports = baseForOwn;

/***/ }), /* 226 */ /***/ (function(module, exports, webpack_require) {

var createBaseFor = webpack_require(227);

/**

* The base implementation of `baseForOwn` which iterates over `object`
* properties returned by `keysFunc` and invokes `iteratee` for each property.
* Iteratee functions may exit iteration early by explicitly returning `false`.
*
* @private
* @param {Object} object The object to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @param {Function} keysFunc The function to get the keys of `object`.
* @returns {Object} Returns `object`.
*/

var baseFor = createBaseFor();

module.exports = baseFor;

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

/**

* Creates a base function for methods like `_.forIn` and `_.forOwn`.
*
* @private
* @param {boolean} [fromRight] Specify iterating from right to left.
* @returns {Function} Returns the new base function.
*/

function createBaseFor(fromRight) {

return function(object, iteratee, keysFunc) {
  var index = -1,
      iterable = Object(object),
      props = keysFunc(object),
      length = props.length;

  while (length--) {
    var key = props[fromRight ? length : ++index];
    if (iteratee(iterable[key], key, iterable) === false) {
      break;
    }
  }
  return object;
};

}

module.exports = createBaseFor;

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

/**

* 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;

}

module.exports = baseTimes;

/***/ }), /* 229 */ /***/ (function(module, exports, webpack_require) {

var baseGetTag = webpack_require(11),

isObjectLike = __webpack_require__(12);

/** `Object#toString` result references. */ var argsTag = '[object Arguments]';

/**

* The base implementation of `_.isArguments`.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an `arguments` object,
*/

function baseIsArguments(value) {

return isObjectLike(value) && baseGetTag(value) == argsTag;

}

module.exports = baseIsArguments;

/***/ }), /* 230 */ /***/ (function(module, exports, webpack_require) {

var Symbol = webpack_require(22);

/** Used for built-in method references. */ var objectProto = Object.prototype;

/** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty;

/**

* Used to resolve the
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
* of values.
*/

var nativeObjectToString = objectProto.toString;

/** Built-in value references. */ var symToStringTag = Symbol ? Symbol.toStringTag : undefined;

/**

* A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
*
* @private
* @param {*} value The value to query.
* @returns {string} Returns the raw `toStringTag`.
*/

function getRawTag(value) {

var isOwn = hasOwnProperty.call(value, symToStringTag),
    tag = value[symToStringTag];

try {
  value[symToStringTag] = undefined;
  var unmasked = true;
} catch (e) {}

var result = nativeObjectToString.call(value);
if (unmasked) {
  if (isOwn) {
    value[symToStringTag] = tag;
  } else {
    delete value[symToStringTag];
  }
}
return result;

}

module.exports = getRawTag;

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

/** Used for built-in method references. */ var objectProto = Object.prototype;

/**

* Used to resolve the
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
* of values.
*/

var nativeObjectToString = objectProto.toString;

/**

* Converts `value` to a string using `Object.prototype.toString`.
*
* @private
* @param {*} value The value to convert.
* @returns {string} Returns the converted string.
*/

function objectToString(value) {

return nativeObjectToString.call(value);

}

module.exports = objectToString;

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

/**

* This method returns `false`.
*
* @static
* @memberOf _
* @since 4.13.0
* @category Util
* @returns {boolean} Returns `false`.
* @example
*
* _.times(2, _.stubFalse);
* // => [false, false]
*/

function stubFalse() {

return false;

}

module.exports = stubFalse;

/***/ }), /* 233 */ /***/ (function(module, exports, webpack_require) {

var baseGetTag = webpack_require(11),

isLength = __webpack_require__(33),
isObjectLike = __webpack_require__(12);

/** `Object#toString` result references. */ var argsTag = '[object Arguments]',

arrayTag = '[object Array]',
boolTag = '[object Boolean]',
dateTag = '[object Date]',
errorTag = '[object Error]',
funcTag = '[object Function]',
mapTag = '[object Map]',
numberTag = '[object Number]',
objectTag = '[object Object]',
regexpTag = '[object RegExp]',
setTag = '[object Set]',
stringTag = '[object String]',
weakMapTag = '[object WeakMap]';

var arrayBufferTag = '[object ArrayBuffer]',

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 identify `toStringTag` values of typed arrays. */ var typedArrayTags = {}; typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = true; typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = typedArrayTags = false;

/**

* The base implementation of `_.isTypedArray` without Node.js optimizations.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
*/

function baseIsTypedArray(value) {

return isObjectLike(value) &&
  isLength(value.length) && !!typedArrayTags[baseGetTag(value)];

}

module.exports = baseIsTypedArray;

/***/ }), /* 234 */ /***/ (function(module, exports, webpack_require) {

/* WEBPACK VAR INJECTION */(function(module) {var freeGlobal = webpack_require(176);

/** 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;

/** Detect free variable `process` from Node.js. */ var freeProcess = moduleExports && freeGlobal.process;

/** Used to access faster Node.js helpers. */ var nodeUtil = (function() {

try {
  return freeProcess && freeProcess.binding && freeProcess.binding('util');
} catch (e) {}

}());

module.exports = nodeUtil;

/* WEBPACK VAR INJECTION */}.call(exports, webpack_require(3)(module)))

/***/ }), /* 235 */ /***/ (function(module, exports, webpack_require) {

var isPrototype = webpack_require(180),

nativeKeys = __webpack_require__(236);

/** Used for built-in method references. */ var objectProto = Object.prototype;

/** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty;

/**

* The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
*/

function baseKeys(object) {

if (!isPrototype(object)) {
  return nativeKeys(object);
}
var result = [];
for (var key in Object(object)) {
  if (hasOwnProperty.call(object, key) && key != 'constructor') {
    result.push(key);
  }
}
return result;

}

module.exports = baseKeys;

/***/ }), /* 236 */ /***/ (function(module, exports, webpack_require) {

var overArg = webpack_require(237);

/* Built-in method references for those with the same name as other `lodash` methods. */ var nativeKeys = overArg(Object.keys, Object);

module.exports = nativeKeys;

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

/**

* 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));
};

}

module.exports = overArg;

/***/ }), /* 238 */ /***/ (function(module, exports, webpack_require) {

var isArrayLike = webpack_require(13);

/**

* Creates a `baseEach` or `baseEachRight` function.
*
* @private
* @param {Function} eachFunc The function to iterate over a collection.
* @param {boolean} [fromRight] Specify iterating from right to left.
* @returns {Function} Returns the new base function.
*/

function createBaseEach(eachFunc, fromRight) {

return function(collection, iteratee) {
  if (collection == null) {
    return collection;
  }
  if (!isArrayLike(collection)) {
    return eachFunc(collection, iteratee);
  }
  var length = collection.length,
      index = fromRight ? length : -1,
      iterable = Object(collection);

  while ((fromRight ? index-- : ++index < length)) {
    if (iteratee(iterable[index], index, iterable) === false) {
      break;
    }
  }
  return collection;
};

}

module.exports = createBaseEach;

/***/ }), /* 239 */ /***/ (function(module, exports, webpack_require) {

var identity = webpack_require(18);

/**

* Casts `value` to `identity` if it's not a function.
*
* @private
* @param {*} value The value to inspect.
* @returns {Function} Returns cast function.
*/

function castFunction(value) {

return typeof value == 'function' ? value : identity;

}

module.exports = castFunction;

/***/ }), /* 240 */ /***/ (function(module, exports, webpack_require) {

module.exports = webpack_require(241);

/***/ }), /* 241 */ /***/ (function(module, exports, webpack_require) {

var copyObject = webpack_require(242),

createAssigner = __webpack_require__(248),
keysIn = __webpack_require__(257);

/**

* This method is like `_.assign` except that it iterates over own and
* inherited source properties.
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 4.0.0
* @alias extend
* @category Object
* @param {Object} object The destination object.
* @param {...Object} [sources] The source objects.
* @returns {Object} Returns `object`.
* @see _.assign
* @example
*
* function Foo() {
*   this.a = 1;
* }
*
* function Bar() {
*   this.c = 3;
* }
*
* Foo.prototype.b = 2;
* Bar.prototype.d = 4;
*
* _.assignIn({ 'a': 0 }, new Foo, new Bar);
* // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }
*/

var assignIn = createAssigner(function(object, source) {

copyObject(source, keysIn(source), object);

});

module.exports = assignIn;

/***/ }), /* 242 */ /***/ (function(module, exports, webpack_require) {

var assignValue = webpack_require(243),

baseAssignValue = __webpack_require__(182);

/**

* Copies properties of `source` to `object`.
*
* @private
* @param {Object} source The object to copy properties from.
* @param {Array} props The property identifiers to copy.
* @param {Object} [object={}] The object to copy properties to.
* @param {Function} [customizer] The function to customize copied values.
* @returns {Object} Returns `object`.
*/

function copyObject(source, props, object, customizer) {

var isNew = !object;
object || (object = {});

var index = -1,
    length = props.length;

while (++index < length) {
  var key = props[index];

  var newValue = customizer
    ? customizer(object[key], source[key], key, object, source)
    : undefined;

  if (newValue === undefined) {
    newValue = source[key];
  }
  if (isNew) {
    baseAssignValue(object, key, newValue);
  } else {
    assignValue(object, key, newValue);
  }
}
return object;

}

module.exports = copyObject;

/***/ }), /* 243 */ /***/ (function(module, exports, webpack_require) {

var baseAssignValue = webpack_require(182),

eq = __webpack_require__(23);

/** Used for built-in method references. */ var objectProto = Object.prototype;

/** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty;

/**

* Assigns `value` to `key` of `object` if the existing value is not equivalent
* using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* for equality comparisons.
*
* @private
* @param {Object} object The object to modify.
* @param {string} key The key of the property to assign.
* @param {*} value The value to assign.
*/

function assignValue(object, key, value) {

var objValue = object[key];
if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
    (value === undefined && !(key in object))) {
  baseAssignValue(object, key, value);
}

}

module.exports = assignValue;

/***/ }), /* 244 */ /***/ (function(module, exports, webpack_require) {

var isFunction = webpack_require(181),

isMasked = __webpack_require__(245),
isObject = __webpack_require__(14),
toSource = __webpack_require__(184);

/**

* Used to match `RegExp`
* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
*/

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

/** Used to detect host constructors (Safari). */ var reIsHostCtor = /^[object .+?Constructor]$/;

/** Used for built-in method references. */ var funcProto = Function.prototype,

objectProto = Object.prototype;

/** 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 detect if a method is native. */ var reIsNative = RegExp('^' +

funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'

);

/**

* The base implementation of `_.isNative` without bad shim checks.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a native function,
*  else `false`.
*/

function baseIsNative(value) {

if (!isObject(value) || isMasked(value)) {
  return false;
}
var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
return pattern.test(toSource(value));

}

module.exports = baseIsNative;

/***/ }), /* 245 */ /***/ (function(module, exports, webpack_require) {

var coreJsData = webpack_require(246);

/** 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) : '';

}());

/**

* Checks if `func` has its source masked.
*
* @private
* @param {Function} func The function to check.
* @returns {boolean} Returns `true` if `func` is masked, else `false`.
*/

function isMasked(func) {

return !!maskSrcKey && (maskSrcKey in func);

}

module.exports = isMasked;

/***/ }), /* 246 */ /***/ (function(module, exports, webpack_require) {

var root = webpack_require(5);

/** Used to detect overreaching core-js shims. */ var coreJsData = root[‘core-js_shared’];

module.exports = coreJsData;

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

/**

* 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];

}

module.exports = getValue;

/***/ }), /* 248 */ /***/ (function(module, exports, webpack_require) {

var baseRest = webpack_require(249),

isIterateeCall = __webpack_require__(256);

/**

* Creates a function like `_.assign`.
*
* @private
* @param {Function} assigner The function to assign values.
* @returns {Function} Returns the new assigner function.
*/

function createAssigner(assigner) {

return baseRest(function(object, sources) {
  var index = -1,
      length = sources.length,
      customizer = length > 1 ? sources[length - 1] : undefined,
      guard = length > 2 ? sources[2] : undefined;

  customizer = (assigner.length > 3 && typeof customizer == 'function')
    ? (length--, customizer)
    : undefined;

  if (guard && isIterateeCall(sources[0], sources[1], guard)) {
    customizer = length < 3 ? undefined : customizer;
    length = 1;
  }
  object = Object(object);
  while (++index < length) {
    var source = sources[index];
    if (source) {
      assigner(object, source, index, customizer);
    }
  }
  return object;
});

}

module.exports = createAssigner;

/***/ }), /* 249 */ /***/ (function(module, exports, webpack_require) {

var identity = webpack_require(18),

overRest = __webpack_require__(250),
setToString = __webpack_require__(252);

/**

* The base implementation of `_.rest` which doesn't validate or coerce arguments.
*
* @private
* @param {Function} func The function to apply a rest parameter to.
* @param {number} [start=func.length-1] The start position of the rest parameter.
* @returns {Function} Returns the new function.
*/

function baseRest(func, start) {

return setToString(overRest(func, start, identity), func + '');

}

module.exports = baseRest;

/***/ }), /* 250 */ /***/ (function(module, exports, webpack_require) {

var apply = webpack_require(251);

/* Built-in method references for those with the same name as other `lodash` methods. */ var nativeMax = Math.max;

/**

* A specialized version of `baseRest` which transforms the rest array.
*
* @private
* @param {Function} func The function to apply a rest parameter to.
* @param {number} [start=func.length-1] The start position of the rest parameter.
* @param {Function} transform The rest array transform.
* @returns {Function} Returns the new function.
*/

function overRest(func, start, transform) {

start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
return function() {
  var args = arguments,
      index = -1,
      length = nativeMax(args.length - start, 0),
      array = Array(length);

  while (++index < length) {
    array[index] = args[start + index];
  }
  index = -1;
  var otherArgs = Array(start + 1);
  while (++index < start) {
    otherArgs[index] = args[index];
  }
  otherArgs[start] = transform(array);
  return apply(func, this, otherArgs);
};

}

module.exports = overRest;

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

/**

* A faster alternative to `Function#apply`, this function invokes `func`
* with the `this` binding of `thisArg` and the arguments of `args`.
*
* @private
* @param {Function} func The function to invoke.
* @param {*} thisArg The `this` binding of `func`.
* @param {Array} args The arguments to invoke `func` with.
* @returns {*} Returns the result of `func`.
*/

function apply(func, thisArg, args) {

switch (args.length) {
  case 0: return func.call(thisArg);
  case 1: return func.call(thisArg, args[0]);
  case 2: return func.call(thisArg, args[0], args[1]);
  case 3: return func.call(thisArg, args[0], args[1], args[2]);
}
return func.apply(thisArg, args);

}

module.exports = apply;

/***/ }), /* 252 */ /***/ (function(module, exports, webpack_require) {

var baseSetToString = webpack_require(253),

shortOut = __webpack_require__(255);

/**

* Sets the `toString` method of `func` to return `string`.
*
* @private
* @param {Function} func The function to modify.
* @param {Function} string The `toString` result.
* @returns {Function} Returns `func`.
*/

var setToString = shortOut(baseSetToString);

module.exports = setToString;

/***/ }), /* 253 */ /***/ (function(module, exports, webpack_require) {

var constant = webpack_require(254),

defineProperty = __webpack_require__(183),
identity = __webpack_require__(18);

/**

* The base implementation of `setToString` without support for hot loop shorting.
*
* @private
* @param {Function} func The function to modify.
* @param {Function} string The `toString` result.
* @returns {Function} Returns `func`.
*/

var baseSetToString = !defineProperty ? identity : function(func, string) {

return defineProperty(func, 'toString', {
  'configurable': true,
  'enumerable': false,
  'value': constant(string),
  'writable': true
});

};

module.exports = baseSetToString;

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

/**

* Creates a function that returns `value`.
*
* @static
* @memberOf _
* @since 2.4.0
* @category Util
* @param {*} value The value to return from the new function.
* @returns {Function} Returns the new constant function.
* @example
*
* var objects = _.times(2, _.constant({ 'a': 1 }));
*
* console.log(objects);
* // => [{ 'a': 1 }, { 'a': 1 }]
*
* console.log(objects[0] === objects[1]);
* // => true
*/

function constant(value) {

return function() {
  return value;
};

}

module.exports = constant;

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

/** Used to detect hot functions by number of calls within a span of milliseconds. */ var HOT_COUNT = 800,

HOT_SPAN = 16;

/* Built-in method references for those with the same name as other `lodash` methods. */ var nativeNow = Date.now;

/**

* Creates a function that'll short out and invoke `identity` instead
* of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
* milliseconds.
*
* @private
* @param {Function} func The function to restrict.
* @returns {Function} Returns the new shortable function.
*/

function shortOut(func) {

var count = 0,
    lastCalled = 0;

return function() {
  var stamp = nativeNow(),
      remaining = HOT_SPAN - (stamp - lastCalled);

  lastCalled = stamp;
  if (remaining > 0) {
    if (++count >= HOT_COUNT) {
      return arguments[0];
    }
  } else {
    count = 0;
  }
  return func.apply(undefined, arguments);
};

}

module.exports = shortOut;

/***/ }), /* 256 */ /***/ (function(module, exports, webpack_require) {

var eq = webpack_require(23),

isArrayLike = __webpack_require__(13),
isIndex = __webpack_require__(32),
isObject = __webpack_require__(14);

/**

* Checks if the given arguments are from an iteratee call.
*
* @private
* @param {*} value The potential iteratee value argument.
* @param {*} index The potential iteratee index or key argument.
* @param {*} object The potential iteratee object argument.
* @returns {boolean} Returns `true` if the arguments are from an iteratee call,
*  else `false`.
*/

function isIterateeCall(value, index, object) {

if (!isObject(object)) {
  return false;
}
var type = typeof index;
if (type == 'number'
      ? (isArrayLike(object) && isIndex(index, object.length))
      : (type == 'string' && index in object)
    ) {
  return eq(object[index], value);
}
return false;

}

module.exports = isIterateeCall;

/***/ }), /* 257 */ /***/ (function(module, exports, webpack_require) {

var arrayLikeKeys = webpack_require(174),

baseKeysIn = __webpack_require__(258),
isArrayLike = __webpack_require__(13);

/**

* Creates an array of the own and inherited enumerable property names of `object`.
*
* **Note:** Non-object values are coerced to objects.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Object
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
* @example
*
* function Foo() {
*   this.a = 1;
*   this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.keysIn(new Foo);
* // => ['a', 'b', 'c'] (iteration order is not guaranteed)
*/

function keysIn(object) {

return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);

}

module.exports = keysIn;

/***/ }), /* 258 */ /***/ (function(module, exports, webpack_require) {

var isObject = webpack_require(14),

isPrototype = __webpack_require__(180),
nativeKeysIn = __webpack_require__(259);

/** Used for built-in method references. */ var objectProto = Object.prototype;

/** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty;

/**

* The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
*/

function baseKeysIn(object) {

if (!isObject(object)) {
  return nativeKeysIn(object);
}
var isProto = isPrototype(object),
    result = [];

for (var key in object) {
  if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
    result.push(key);
  }
}
return result;

}

module.exports = baseKeysIn;

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

/**

* This function is like
* [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
* except that it includes inherited enumerable properties.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
*/

function nativeKeysIn(object) {

var result = [];
if (object != null) {
  for (var key in Object(object)) {
    result.push(key);
  }
}
return result;

}

module.exports = nativeKeysIn;

/***/ }), /* 260 */ /***/ (function(module, exports, webpack_require) {

var createFind = webpack_require(261),

findIndex = __webpack_require__(318);

/**

* Iterates over elements of `collection`, returning the first element
* `predicate` returns truthy for. The predicate is invoked with three
* arguments: (value, index|key, collection).
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to inspect.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @param {number} [fromIndex=0] The index to search from.
* @returns {*} Returns the matched element, else `undefined`.
* @example
*
* var users = [
*   { 'user': 'barney',  'age': 36, 'active': true },
*   { 'user': 'fred',    'age': 40, 'active': false },
*   { 'user': 'pebbles', 'age': 1,  'active': true }
* ];
*
* _.find(users, function(o) { return o.age < 40; });
* // => object for 'barney'
*
* // The `_.matches` iteratee shorthand.
* _.find(users, { 'age': 1, 'active': true });
* // => object for 'pebbles'
*
* // The `_.matchesProperty` iteratee shorthand.
* _.find(users, ['active', false]);
* // => object for 'fred'
*
* // The `_.property` iteratee shorthand.
* _.find(users, 'active');
* // => object for 'barney'
*/

var find = createFind(findIndex);

module.exports = find;

/***/ }), /* 261 */ /***/ (function(module, exports, webpack_require) {

var baseIteratee = webpack_require(15),

isArrayLike = __webpack_require__(13),
keys = __webpack_require__(21);

/**

* Creates a `_.find` or `_.findLast` function.
*
* @private
* @param {Function} findIndexFunc The function to find the collection index.
* @returns {Function} Returns the new find function.
*/

function createFind(findIndexFunc) {

return function(collection, predicate, fromIndex) {
  var iterable = Object(collection);
  if (!isArrayLike(collection)) {
    var iteratee = baseIteratee(predicate, 3);
    collection = keys(collection);
    predicate = function(key) { return iteratee(iterable[key], key, iterable); };
  }
  var index = findIndexFunc(collection, predicate, fromIndex);
  return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
};

}

module.exports = createFind;

/***/ }), /* 262 */ /***/ (function(module, exports, webpack_require) {

var baseIsMatch = webpack_require(263),

getMatchData = __webpack_require__(304),
matchesStrictComparable = __webpack_require__(192);

/**

* The base implementation of `_.matches` which doesn't clone `source`.
*
* @private
* @param {Object} source The object of property values to match.
* @returns {Function} Returns the new spec function.
*/

function baseMatches(source) {

var matchData = getMatchData(source);
if (matchData.length == 1 && matchData[0][2]) {
  return matchesStrictComparable(matchData[0][0], matchData[0][1]);
}
return function(object) {
  return object === source || baseIsMatch(object, source, matchData);
};

}

module.exports = baseMatches;

/***/ }), /* 263 */ /***/ (function(module, exports, webpack_require) {

var Stack = webpack_require(185),

baseIsEqual = __webpack_require__(186);

/** Used to compose bitmasks for value comparisons. */ var COMPARE_PARTIAL_FLAG = 1,

COMPARE_UNORDERED_FLAG = 2;

/**

* The base implementation of `_.isMatch` without support for iteratee shorthands.
*
* @private
* @param {Object} object The object to inspect.
* @param {Object} source The object of property values to match.
* @param {Array} matchData The property names, values, and compare flags to match.
* @param {Function} [customizer] The function to customize comparisons.
* @returns {boolean} Returns `true` if `object` is a match, else `false`.
*/

function baseIsMatch(object, source, matchData, customizer) {

var index = matchData.length,
    length = index,
    noCustomizer = !customizer;

if (object == null) {
  return !length;
}
object = Object(object);
while (index--) {
  var data = matchData[index];
  if ((noCustomizer && data[2])
        ? data[1] !== object[data[0]]
        : !(data[0] in object)
      ) {
    return false;
  }
}
while (++index < length) {
  data = matchData[index];
  var key = data[0],
      objValue = object[key],
      srcValue = data[1];

  if (noCustomizer && data[2]) {
    if (objValue === undefined && !(key in object)) {
      return false;
    }
  } else {
    var stack = new Stack;
    if (customizer) {
      var result = customizer(objValue, srcValue, key, object, source, stack);
    }
    if (!(result === undefined
          ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
          : result
        )) {
      return false;
    }
  }
}
return true;

}

module.exports = baseIsMatch;

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

/**

* Removes all key-value entries from the list cache.
*
* @private
* @name clear
* @memberOf ListCache
*/

function listCacheClear() {

this.__data__ = [];
this.size = 0;

}

module.exports = listCacheClear;

/***/ }), /* 265 */ /***/ (function(module, exports, webpack_require) {

var assocIndexOf = webpack_require(25);

/** Used for built-in method references. */ var arrayProto = Array.prototype;

/** Built-in value references. */ var splice = arrayProto.splice;

/**

* Removes `key` and its value from the list cache.
*
* @private
* @name delete
* @memberOf ListCache
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/

function listCacheDelete(key) {

var data = this.__data__,
    index = assocIndexOf(data, key);

if (index < 0) {
  return false;
}
var lastIndex = data.length - 1;
if (index == lastIndex) {
  data.pop();
} else {
  splice.call(data, index, 1);
}
--this.size;
return true;

}

module.exports = listCacheDelete;

/***/ }), /* 266 */ /***/ (function(module, exports, webpack_require) {

var assocIndexOf = webpack_require(25);

/**

* Gets the list cache value for `key`.
*
* @private
* @name get
* @memberOf ListCache
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/

function listCacheGet(key) {

var data = this.__data__,
    index = assocIndexOf(data, key);

return index < 0 ? undefined : data[index][1];

}

module.exports = listCacheGet;

/***/ }), /* 267 */ /***/ (function(module, exports, webpack_require) {

var assocIndexOf = webpack_require(25);

/**

* Checks if a list cache value for `key` exists.
*
* @private
* @name has
* @memberOf ListCache
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/

function listCacheHas(key) {

return assocIndexOf(this.__data__, key) > -1;

}

module.exports = listCacheHas;

/***/ }), /* 268 */ /***/ (function(module, exports, webpack_require) {

var assocIndexOf = webpack_require(25);

/**

* Sets the list cache `key` to `value`.
*
* @private
* @name set
* @memberOf ListCache
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the list cache instance.
*/

function listCacheSet(key, value) {

var data = this.__data__,
    index = assocIndexOf(data, key);

if (index < 0) {
  ++this.size;
  data.push([key, value]);
} else {
  data[index][1] = value;
}
return this;

}

module.exports = listCacheSet;

/***/ }), /* 269 */ /***/ (function(module, exports, webpack_require) {

var ListCache = webpack_require(24);

/**

* Removes all key-value entries from the stack.
*
* @private
* @name clear
* @memberOf Stack
*/

function stackClear() {

this.__data__ = new ListCache;
this.size = 0;

}

module.exports = stackClear;

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

/**

* Removes `key` and its value from the stack.
*
* @private
* @name delete
* @memberOf Stack
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/

function stackDelete(key) {

var data = this.__data__,
    result = data['delete'](key);

this.size = data.size;
return result;

}

module.exports = stackDelete;

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

/**

* Gets the stack value for `key`.
*
* @private
* @name get
* @memberOf Stack
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/

function stackGet(key) {

return this.__data__.get(key);

}

module.exports = stackGet;

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

/**

* Checks if a stack value for `key` exists.
*
* @private
* @name has
* @memberOf Stack
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/

function stackHas(key) {

return this.__data__.has(key);

}

module.exports = stackHas;

/***/ }), /* 273 */ /***/ (function(module, exports, webpack_require) {

var ListCache = webpack_require(24),

Map = __webpack_require__(34),
MapCache = __webpack_require__(35);

/** Used as the size to enable large array optimizations. */ var LARGE_ARRAY_SIZE = 200;

/**

* Sets the stack `key` to `value`.
*
* @private
* @name set
* @memberOf Stack
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the stack cache instance.
*/

function stackSet(key, value) {

var data = this.__data__;
if (data instanceof ListCache) {
  var pairs = data.__data__;
  if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
    pairs.push([key, value]);
    this.size = ++data.size;
    return this;
  }
  data = this.__data__ = new MapCache(pairs);
}
data.set(key, value);
this.size = data.size;
return this;

}

module.exports = stackSet;

/***/ }), /* 274 */ /***/ (function(module, exports, webpack_require) {

var Hash = webpack_require(275),

ListCache = __webpack_require__(24),
Map = __webpack_require__(34);

/**

* Removes all key-value entries from the map.
*
* @private
* @name clear
* @memberOf MapCache
*/

function mapCacheClear() {

this.size = 0;
this.__data__ = {
  'hash': new Hash,
  'map': new (Map || ListCache),
  'string': new Hash
};

}

module.exports = mapCacheClear;

/***/ }), /* 275 */ /***/ (function(module, exports, webpack_require) {

var hashClear = webpack_require(276),

hashDelete = __webpack_require__(277),
hashGet = __webpack_require__(278),
hashHas = __webpack_require__(279),
hashSet = __webpack_require__(280);

/**

* Creates a hash object.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/

function Hash(entries) {

var index = -1,
    length = entries == null ? 0 : entries.length;

this.clear();
while (++index < length) {
  var entry = entries[index];
  this.set(entry[0], entry[1]);
}

}

// Add methods to `Hash`. Hash.prototype.clear = hashClear; Hash.prototype = hashDelete; Hash.prototype.get = hashGet; Hash.prototype.has = hashHas; Hash.prototype.set = hashSet;

module.exports = Hash;

/***/ }), /* 276 */ /***/ (function(module, exports, webpack_require) {

var nativeCreate = webpack_require(26);

/**

* Removes all key-value entries from the hash.
*
* @private
* @name clear
* @memberOf Hash
*/

function hashClear() {

this.__data__ = nativeCreate ? nativeCreate(null) : {};
this.size = 0;

}

module.exports = hashClear;

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

/**

* 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) {

var result = this.has(key) && delete this.__data__[key];
this.size -= result ? 1 : 0;
return result;

}

module.exports = hashDelete;

/***/ }), /* 278 */ /***/ (function(module, exports, webpack_require) {

var nativeCreate = webpack_require(26);

/** Used to stand-in for `undefined` hash values. */ var HASH_UNDEFINED = 'lodash_hash_undefined';

/** Used for built-in method references. */ var objectProto = Object.prototype;

/** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty;

/**

* 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;

}

module.exports = hashGet;

/***/ }), /* 279 */ /***/ (function(module, exports, webpack_require) {

var nativeCreate = webpack_require(26);

/** Used for built-in method references. */ var objectProto = Object.prototype;

/** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty;

/**

* Checks if a hash value for `key` exists.
*
* @private
* @name has
* @memberOf Hash
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/

function hashHas(key) {

var data = this.__data__;
return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);

}

module.exports = hashHas;

/***/ }), /* 280 */ /***/ (function(module, exports, webpack_require) {

var nativeCreate = webpack_require(26);

/** Used to stand-in for `undefined` hash values. */ var HASH_UNDEFINED = 'lodash_hash_undefined';

/**

* Sets the hash `key` to `value`.
*
* @private
* @name set
* @memberOf Hash
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the hash instance.
*/

function hashSet(key, value) {

var data = this.__data__;
this.size += this.has(key) ? 0 : 1;
data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
return this;

}

module.exports = hashSet;

/***/ }), /* 281 */ /***/ (function(module, exports, webpack_require) {

var getMapData = webpack_require(27);

/**

* Removes `key` and its value from the map.
*
* @private
* @name delete
* @memberOf MapCache
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/

function mapCacheDelete(key) {

var result = getMapData(this, key)['delete'](key);
this.size -= result ? 1 : 0;
return result;

}

module.exports = mapCacheDelete;

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

/**

* Checks if `value` is suitable for use as unique object key.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is suitable, else `false`.
*/

function isKeyable(value) {

var type = typeof value;
return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
  ? (value !== '__proto__')
  : (value === null);

}

module.exports = isKeyable;

/***/ }), /* 283 */ /***/ (function(module, exports, webpack_require) {

var getMapData = webpack_require(27);

/**

* Gets the map value for `key`.
*
* @private
* @name get
* @memberOf MapCache
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/

function mapCacheGet(key) {

return getMapData(this, key).get(key);

}

module.exports = mapCacheGet;

/***/ }), /* 284 */ /***/ (function(module, exports, webpack_require) {

var getMapData = webpack_require(27);

/**

* Checks if a map value for `key` exists.
*
* @private
* @name has
* @memberOf MapCache
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/

function mapCacheHas(key) {

return getMapData(this, key).has(key);

}

module.exports = mapCacheHas;

/***/ }), /* 285 */ /***/ (function(module, exports, webpack_require) {

var getMapData = webpack_require(27);

/**

* Sets the map `key` to `value`.
*
* @private
* @name set
* @memberOf MapCache
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the map cache instance.
*/

function mapCacheSet(key, value) {

var data = getMapData(this, key),
    size = data.size;

data.set(key, value);
this.size += data.size == size ? 0 : 1;
return this;

}

module.exports = mapCacheSet;

/***/ }), /* 286 */ /***/ (function(module, exports, webpack_require) {

var Stack = webpack_require(185),

equalArrays = __webpack_require__(187),
equalByTag = __webpack_require__(290),
equalObjects = __webpack_require__(293),
getTag = __webpack_require__(300),
isArray = __webpack_require__(2),
isBuffer = __webpack_require__(177),
isTypedArray = __webpack_require__(178);

/** Used to compose bitmasks for value comparisons. */ var COMPARE_PARTIAL_FLAG = 1;

/** `Object#toString` result references. */ var argsTag = '[object Arguments]',

arrayTag = '[object Array]',
objectTag = '[object Object]';

/** Used for built-in method references. */ var objectProto = Object.prototype;

/** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty;

/**

* A specialized version of `baseIsEqual` for arrays and objects which performs
* deep comparisons and tracks traversed objects enabling objects with circular
* references to be compared.
*
* @private
* @param {Object} object The object to compare.
* @param {Object} other The other object to compare.
* @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
* @param {Function} customizer The function to customize comparisons.
* @param {Function} equalFunc The function to determine equivalents of values.
* @param {Object} [stack] Tracks traversed `object` and `other` objects.
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
*/

function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {

var objIsArr = isArray(object),
    othIsArr = isArray(other),
    objTag = objIsArr ? arrayTag : getTag(object),
    othTag = othIsArr ? arrayTag : getTag(other);

objTag = objTag == argsTag ? objectTag : objTag;
othTag = othTag == argsTag ? objectTag : othTag;

var objIsObj = objTag == objectTag,
    othIsObj = othTag == objectTag,
    isSameTag = objTag == othTag;

if (isSameTag && isBuffer(object)) {
  if (!isBuffer(other)) {
    return false;
  }
  objIsArr = true;
  objIsObj = false;
}
if (isSameTag && !objIsObj) {
  stack || (stack = new Stack);
  return (objIsArr || isTypedArray(object))
    ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
    : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
}
if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
  var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
      othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');

  if (objIsWrapped || othIsWrapped) {
    var objUnwrapped = objIsWrapped ? object.value() : object,
        othUnwrapped = othIsWrapped ? other.value() : other;

    stack || (stack = new Stack);
    return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
  }
}
if (!isSameTag) {
  return false;
}
stack || (stack = new Stack);
return equalObjects(object, other, bitmask, customizer, equalFunc, stack);

}

module.exports = baseIsEqualDeep;

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

/** Used to stand-in for `undefined` hash values. */ var HASH_UNDEFINED = 'lodash_hash_undefined';

/**

* Adds `value` to the array cache.
*
* @private
* @name add
* @memberOf SetCache
* @alias push
* @param {*} value The value to cache.
* @returns {Object} Returns the cache instance.
*/

function setCacheAdd(value) {

this.__data__.set(value, HASH_UNDEFINED);
return this;

}

module.exports = setCacheAdd;

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

/**

* Checks if `value` is in the array cache.
*
* @private
* @name has
* @memberOf SetCache
* @param {*} value The value to search for.
* @returns {number} Returns `true` if `value` is found, else `false`.
*/

function setCacheHas(value) {

return this.__data__.has(value);

}

module.exports = setCacheHas;

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

/**

* A specialized version of `_.some` for arrays without support for iteratee
* shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} predicate The function invoked per iteration.
* @returns {boolean} Returns `true` if any element passes the predicate check,
*  else `false`.
*/

function arraySome(array, predicate) {

var index = -1,
    length = array == null ? 0 : array.length;

while (++index < length) {
  if (predicate(array[index], index, array)) {
    return true;
  }
}
return false;

}

module.exports = arraySome;

/***/ }), /* 290 */ /***/ (function(module, exports, webpack_require) {

var Symbol = webpack_require(22),

Uint8Array = __webpack_require__(291),
eq = __webpack_require__(23),
equalArrays = __webpack_require__(187),
mapToArray = __webpack_require__(292),
setToArray = __webpack_require__(36);

/** Used to compose bitmasks for value comparisons. */ var COMPARE_PARTIAL_FLAG = 1,

COMPARE_UNORDERED_FLAG = 2;

/** `Object#toString` result references. */ var boolTag = '[object Boolean]',

dateTag = '[object Date]',
errorTag = '[object Error]',
mapTag = '[object Map]',
numberTag = '[object Number]',
regexpTag = '[object RegExp]',
setTag = '[object Set]',
stringTag = '[object String]',
symbolTag = '[object Symbol]';

var arrayBufferTag = '[object ArrayBuffer]',

dataViewTag = '[object DataView]';

/** Used to convert symbols to primitives and strings. */ var symbolProto = Symbol ? Symbol.prototype : undefined,

symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;

/**

* A specialized version of `baseIsEqualDeep` for comparing objects of
* the same `toStringTag`.
*
* **Note:** This function only supports comparing values with tags of
* `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
*
* @private
* @param {Object} object The object to compare.
* @param {Object} other The other object to compare.
* @param {string} tag The `toStringTag` of the objects to compare.
* @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
* @param {Function} customizer The function to customize comparisons.
* @param {Function} equalFunc The function to determine equivalents of values.
* @param {Object} stack Tracks traversed `object` and `other` objects.
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
*/

function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {

switch (tag) {
  case dataViewTag:
    if ((object.byteLength != other.byteLength) ||
        (object.byteOffset != other.byteOffset)) {
      return false;
    }
    object = object.buffer;
    other = other.buffer;

  case arrayBufferTag:
    if ((object.byteLength != other.byteLength) ||
        !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
      return false;
    }
    return true;

  case boolTag:
  case dateTag:
  case numberTag:
    // Coerce booleans to `1` or `0` and dates to milliseconds.
    // Invalid dates are coerced to `NaN`.
    return eq(+object, +other);

  case errorTag:
    return object.name == other.name && object.message == other.message;

  case regexpTag:
  case stringTag:
    // Coerce regexes to strings and treat strings, primitives and objects,
    // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
    // for more details.
    return object == (other + '');

  case mapTag:
    var convert = mapToArray;

  case setTag:
    var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
    convert || (convert = setToArray);

    if (object.size != other.size && !isPartial) {
      return false;
    }
    // Assume cyclic values are equal.
    var stacked = stack.get(object);
    if (stacked) {
      return stacked == other;
    }
    bitmask |= COMPARE_UNORDERED_FLAG;

    // Recursively compare objects (susceptible to call stack limits).
    stack.set(object, other);
    var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
    stack['delete'](object);
    return result;

  case symbolTag:
    if (symbolValueOf) {
      return symbolValueOf.call(object) == symbolValueOf.call(other);
    }
}
return false;

}

module.exports = equalByTag;

/***/ }), /* 291 */ /***/ (function(module, exports, webpack_require) {

var root = webpack_require(5);

/** Built-in value references. */ var Uint8Array = root.Uint8Array;

module.exports = Uint8Array;

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

/**

* 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;

}

module.exports = mapToArray;

/***/ }), /* 293 */ /***/ (function(module, exports, webpack_require) {

var getAllKeys = webpack_require(294);

/** Used to compose bitmasks for value comparisons. */ var COMPARE_PARTIAL_FLAG = 1;

/** Used for built-in method references. */ var objectProto = Object.prototype;

/** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty;

/**

* A specialized version of `baseIsEqualDeep` for objects with support for
* partial deep comparisons.
*
* @private
* @param {Object} object The object to compare.
* @param {Object} other The other object to compare.
* @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
* @param {Function} customizer The function to customize comparisons.
* @param {Function} equalFunc The function to determine equivalents of values.
* @param {Object} stack Tracks traversed `object` and `other` objects.
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
*/

function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {

var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
    objProps = getAllKeys(object),
    objLength = objProps.length,
    othProps = getAllKeys(other),
    othLength = othProps.length;

if (objLength != othLength && !isPartial) {
  return false;
}
var index = objLength;
while (index--) {
  var key = objProps[index];
  if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
    return false;
  }
}
// Assume cyclic values are equal.
var stacked = stack.get(object);
if (stacked && stack.get(other)) {
  return stacked == other;
}
var result = true;
stack.set(object, other);
stack.set(other, object);

var skipCtor = isPartial;
while (++index < objLength) {
  key = objProps[index];
  var objValue = object[key],
      othValue = other[key];

  if (customizer) {
    var compared = isPartial
      ? customizer(othValue, objValue, key, other, object, stack)
      : customizer(objValue, othValue, key, object, other, stack);
  }
  // Recursively compare objects (susceptible to call stack limits).
  if (!(compared === undefined
        ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
        : compared
      )) {
    result = false;
    break;
  }
  skipCtor || (skipCtor = key == 'constructor');
}
if (result && !skipCtor) {
  var objCtor = object.constructor,
      othCtor = other.constructor;

  // Non `Object` object instances with different constructors are not equal.
  if (objCtor != othCtor &&
      ('constructor' in object && 'constructor' in other) &&
      !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
        typeof othCtor == 'function' && othCtor instanceof othCtor)) {
    result = false;
  }
}
stack['delete'](object);
stack['delete'](other);
return result;

}

module.exports = equalObjects;

/***/ }), /* 294 */ /***/ (function(module, exports, webpack_require) {

var baseGetAllKeys = webpack_require(295),

getSymbols = __webpack_require__(297),
keys = __webpack_require__(21);

/**

* Creates an array of own enumerable property names and symbols of `object`.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names and symbols.
*/

function getAllKeys(object) {

return baseGetAllKeys(object, keys, getSymbols);

}

module.exports = getAllKeys;

/***/ }), /* 295 */ /***/ (function(module, exports, webpack_require) {

var arrayPush = webpack_require(296),

isArray = __webpack_require__(2);

/**

* The base implementation of `getAllKeys` and `getAllKeysIn` which uses
* `keysFunc` and `symbolsFunc` to get the enumerable property names and
* symbols of `object`.
*
* @private
* @param {Object} object The object to query.
* @param {Function} keysFunc The function to get the keys of `object`.
* @param {Function} symbolsFunc The function to get the symbols of `object`.
* @returns {Array} Returns the array of property names and symbols.
*/

function baseGetAllKeys(object, keysFunc, symbolsFunc) {

var result = keysFunc(object);
return isArray(object) ? result : arrayPush(result, symbolsFunc(object));

}

module.exports = baseGetAllKeys;

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

/**

* 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;

}

module.exports = arrayPush;

/***/ }), /* 297 */ /***/ (function(module, exports, webpack_require) {

var arrayFilter = webpack_require(298),

stubArray = __webpack_require__(299);

/** Used for built-in method references. */ var objectProto = Object.prototype;

/** Built-in value references. */ var propertyIsEnumerable = objectProto.propertyIsEnumerable;

/* Built-in method references for those with the same name as other `lodash` methods. */ var nativeGetSymbols = Object.getOwnPropertySymbols;

/**

* Creates an array of the own enumerable symbols of `object`.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of symbols.
*/

var getSymbols = !nativeGetSymbols ? stubArray : function(object) {

if (object == null) {
  return [];
}
object = Object(object);
return arrayFilter(nativeGetSymbols(object), function(symbol) {
  return propertyIsEnumerable.call(object, symbol);
});

};

module.exports = getSymbols;

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

/**

* A specialized version of `_.filter` for arrays without support for
* iteratee shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} predicate The function invoked per iteration.
* @returns {Array} Returns the new filtered array.
*/

function arrayFilter(array, predicate) {

var index = -1,
    length = array == null ? 0 : array.length,
    resIndex = 0,
    result = [];

while (++index < length) {
  var value = array[index];
  if (predicate(value, index, array)) {
    result[resIndex++] = value;
  }
}
return result;

}

module.exports = arrayFilter;

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

/**

* This method returns a new empty array.
*
* @static
* @memberOf _
* @since 4.13.0
* @category Util
* @returns {Array} Returns the new empty array.
* @example
*
* var arrays = _.times(2, _.stubArray);
*
* console.log(arrays);
* // => [[], []]
*
* console.log(arrays[0] === arrays[1]);
* // => false
*/

function stubArray() {

return [];

}

module.exports = stubArray;

/***/ }), /* 300 */ /***/ (function(module, exports, webpack_require) {

var DataView = webpack_require(301),

Map = __webpack_require__(34),
Promise = __webpack_require__(302),
Set = __webpack_require__(190),
WeakMap = __webpack_require__(303),
baseGetTag = __webpack_require__(11),
toSource = __webpack_require__(184);

/** `Object#toString` result references. */ var mapTag = '[object Map]',

objectTag = '[object Object]',
promiseTag = '[object Promise]',
setTag = '[object Set]',
weakMapTag = '[object WeakMap]';

var dataViewTag = '[object DataView]';

/** Used to detect maps, sets, and weakmaps. */ var dataViewCtorString = toSource(DataView),

mapCtorString = toSource(Map),
promiseCtorString = toSource(Promise),
setCtorString = toSource(Set),
weakMapCtorString = toSource(WeakMap);

/**

* Gets the `toStringTag` of `value`.
*
* @private
* @param {*} value The value to query.
* @returns {string} Returns the `toStringTag`.
*/

var getTag = baseGetTag;

// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||

  (Map && getTag(new Map) != mapTag) ||
  (Promise && getTag(Promise.resolve()) != promiseTag) ||
  (Set && getTag(new Set) != setTag) ||
  (WeakMap && getTag(new WeakMap) != weakMapTag)) {
getTag = function(value) {
  var result = baseGetTag(value),
      Ctor = result == objectTag ? value.constructor : undefined,
      ctorString = Ctor ? toSource(Ctor) : '';

  if (ctorString) {
    switch (ctorString) {
      case dataViewCtorString: return dataViewTag;
      case mapCtorString: return mapTag;
      case promiseCtorString: return promiseTag;
      case setCtorString: return setTag;
      case weakMapCtorString: return weakMapTag;
    }
  }
  return result;
};

}

module.exports = getTag;

/***/ }), /* 301 */ /***/ (function(module, exports, webpack_require) {

var getNative = webpack_require(10),

root = __webpack_require__(5);

/* Built-in method references that are verified to be native. */ var DataView = getNative(root, 'DataView');

module.exports = DataView;

/***/ }), /* 302 */ /***/ (function(module, exports, webpack_require) {

var getNative = webpack_require(10),

root = __webpack_require__(5);

/* Built-in method references that are verified to be native. */ var Promise = getNative(root, 'Promise');

module.exports = Promise;

/***/ }), /* 303 */ /***/ (function(module, exports, webpack_require) {

var getNative = webpack_require(10),

root = __webpack_require__(5);

/* Built-in method references that are verified to be native. */ var WeakMap = getNative(root, 'WeakMap');

module.exports = WeakMap;

/***/ }), /* 304 */ /***/ (function(module, exports, webpack_require) {

var isStrictComparable = webpack_require(191),

keys = __webpack_require__(21);

/**

* Gets the property names, values, and compare flags of `object`.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the match data of `object`.
*/

function getMatchData(object) {

var result = keys(object),
    length = result.length;

while (length--) {
  var key = result[length],
      value = object[key];

  result[length] = [key, value, isStrictComparable(value)];
}
return result;

}

module.exports = getMatchData;

/***/ }), /* 305 */ /***/ (function(module, exports, webpack_require) {

var baseIsEqual = webpack_require(186),

get = __webpack_require__(306),
hasIn = __webpack_require__(312),
isKey = __webpack_require__(37),
isStrictComparable = __webpack_require__(191),
matchesStrictComparable = __webpack_require__(192),
toKey = __webpack_require__(28);

/** Used to compose bitmasks for value comparisons. */ var COMPARE_PARTIAL_FLAG = 1,

COMPARE_UNORDERED_FLAG = 2;

/**

* The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
*
* @private
* @param {string} path The path of the property to get.
* @param {*} srcValue The value to match.
* @returns {Function} Returns the new spec function.
*/

function baseMatchesProperty(path, srcValue) {

if (isKey(path) && isStrictComparable(srcValue)) {
  return matchesStrictComparable(toKey(path), srcValue);
}
return function(object) {
  var objValue = get(object, path);
  return (objValue === undefined && objValue === srcValue)
    ? hasIn(object, path)
    : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
};

}

module.exports = baseMatchesProperty;

/***/ }), /* 306 */ /***/ (function(module, exports, webpack_require) {

var baseGet = webpack_require(193);

/**

* Gets the value at `path` of `object`. If the resolved value is
* `undefined`, the `defaultValue` is returned in its place.
*
* @static
* @memberOf _
* @since 3.7.0
* @category Object
* @param {Object} object The object to query.
* @param {Array|string} path The path of the property to get.
* @param {*} [defaultValue] The value returned for `undefined` resolved values.
* @returns {*} Returns the resolved value.
* @example
*
* var object = { 'a': [{ 'b': { 'c': 3 } }] };
*
* _.get(object, 'a[0].b.c');
* // => 3
*
* _.get(object, ['a', '0', 'b', 'c']);
* // => 3
*
* _.get(object, 'a.b.c', 'default');
* // => 'default'
*/

function get(object, path, defaultValue) {

var result = object == null ? undefined : baseGet(object, path);
return result === undefined ? defaultValue : result;

}

module.exports = get;

/***/ }), /* 307 */ /***/ (function(module, exports, webpack_require) {

var memoizeCapped = webpack_require(308);

/** Used to match property names within property paths. */ var reLeadingDot = /^./,

rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;

/** Used to match backslashes in property paths. */ var reEscapeChar = /\(\)?/g;

/**

* Converts `string` to a property path array.
*
* @private
* @param {string} string The string to convert.
* @returns {Array} Returns the property path array.
*/

var stringToPath = memoizeCapped(function(string) {

var result = [];
if (reLeadingDot.test(string)) {
  result.push('');
}
string.replace(rePropName, function(match, number, quote, string) {
  result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
});
return result;

});

module.exports = stringToPath;

/***/ }), /* 308 */ /***/ (function(module, exports, webpack_require) {

var memoize = webpack_require(309);

/** Used as the maximum memoize cache size. */ var MAX_MEMOIZE_SIZE = 500;

/**

* A specialized version of `_.memoize` which clears the memoized function's
* cache when it exceeds `MAX_MEMOIZE_SIZE`.
*
* @private
* @param {Function} func The function to have its output memoized.
* @returns {Function} Returns the new memoized function.
*/

function memoizeCapped(func) {

var result = memoize(func, function(key) {
  if (cache.size === MAX_MEMOIZE_SIZE) {
    cache.clear();
  }
  return key;
});

var cache = result.cache;
return result;

}

module.exports = memoizeCapped;

/***/ }), /* 309 */ /***/ (function(module, exports, webpack_require) {

var MapCache = webpack_require(35);

/** Error message constants. */ var FUNC_ERROR_TEXT = 'Expected a function';

/**

* Creates a function that memoizes the result of `func`. If `resolver` is
* provided, it determines the cache key for storing the result based on the
* arguments provided to the memoized function. By default, the first argument
* provided to the memoized function is used as the map cache key. The `func`
* is invoked with the `this` binding of the memoized function.
*
* **Note:** The cache is exposed as the `cache` property on the memoized
* function. Its creation may be customized by replacing the `_.memoize.Cache`
* constructor with one whose instances implement the
* [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
* method interface of `clear`, `delete`, `get`, `has`, and `set`.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Function
* @param {Function} func The function to have its output memoized.
* @param {Function} [resolver] The function to resolve the cache key.
* @returns {Function} Returns the new memoized function.
* @example
*
* var object = { 'a': 1, 'b': 2 };
* var other = { 'c': 3, 'd': 4 };
*
* var values = _.memoize(_.values);
* values(object);
* // => [1, 2]
*
* values(other);
* // => [3, 4]
*
* object.a = 2;
* values(object);
* // => [1, 2]
*
* // Modify the result cache.
* values.cache.set(object, ['a', 'b']);
* values(object);
* // => ['a', 'b']
*
* // Replace `_.memoize.Cache`.
* _.memoize.Cache = WeakMap;
*/

function memoize(func, resolver) {

if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
  throw new TypeError(FUNC_ERROR_TEXT);
}
var memoized = function() {
  var args = arguments,
      key = resolver ? resolver.apply(this, args) : args[0],
      cache = memoized.cache;

  if (cache.has(key)) {
    return cache.get(key);
  }
  var result = func.apply(this, args);
  memoized.cache = cache.set(key, result) || cache;
  return result;
};
memoized.cache = new (memoize.Cache || MapCache);
return memoized;

}

// Expose `MapCache`. memoize.Cache = MapCache;

module.exports = memoize;

/***/ }), /* 310 */ /***/ (function(module, exports, webpack_require) {

var baseToString = webpack_require(311);

/**

* Converts `value` to a string. An empty string is returned for `null`
* and `undefined` values. The sign of `-0` is preserved.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to convert.
* @returns {string} Returns the converted string.
* @example
*
* _.toString(null);
* // => ''
*
* _.toString(-0);
* // => '-0'
*
* _.toString([1, 2, 3]);
* // => '1,2,3'
*/

function toString(value) {

return value == null ? '' : baseToString(value);

}

module.exports = toString;

/***/ }), /* 311 */ /***/ (function(module, exports, webpack_require) {

var Symbol = webpack_require(22),

arrayMap = __webpack_require__(38),
isArray = __webpack_require__(2),
isSymbol = __webpack_require__(16);

/** Used as references for various `Number` constants. */ var INFINITY = 1 / 0;

/** Used to convert symbols to primitives and strings. */ var symbolProto = Symbol ? Symbol.prototype : undefined,

symbolToString = symbolProto ? symbolProto.toString : undefined;

/**

* The base implementation of `_.toString` which doesn't convert nullish
* values to empty strings.
*
* @private
* @param {*} value The value to process.
* @returns {string} Returns the string.
*/

function baseToString(value) {

// Exit early for strings to avoid a performance hit in some environments.
if (typeof value == 'string') {
  return value;
}
if (isArray(value)) {
  // Recursively convert values (susceptible to call stack limits).
  return arrayMap(value, baseToString) + '';
}
if (isSymbol(value)) {
  return symbolToString ? symbolToString.call(value) : '';
}
var result = (value + '');
return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;

}

module.exports = baseToString;

/***/ }), /* 312 */ /***/ (function(module, exports, webpack_require) {

var baseHasIn = webpack_require(313),

hasPath = __webpack_require__(314);

/**

* Checks if `path` is a direct or inherited property of `object`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Object
* @param {Object} object The object to query.
* @param {Array|string} path The path to check.
* @returns {boolean} Returns `true` if `path` exists, else `false`.
* @example
*
* var object = _.create({ 'a': _.create({ 'b': 2 }) });
*
* _.hasIn(object, 'a');
* // => true
*
* _.hasIn(object, 'a.b');
* // => true
*
* _.hasIn(object, ['a', 'b']);
* // => true
*
* _.hasIn(object, 'b');
* // => false
*/

function hasIn(object, path) {

return object != null && hasPath(object, path, baseHasIn);

}

module.exports = hasIn;

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

/**

* The base implementation of `_.hasIn` without support for deep paths.
*
* @private
* @param {Object} [object] The object to query.
* @param {Array|string} key The key to check.
* @returns {boolean} Returns `true` if `key` exists, else `false`.
*/

function baseHasIn(object, key) {

return object != null && key in Object(object);

}

module.exports = baseHasIn;

/***/ }), /* 314 */ /***/ (function(module, exports, webpack_require) {

var castPath = webpack_require(194),

isArguments = __webpack_require__(175),
isArray = __webpack_require__(2),
isIndex = __webpack_require__(32),
isLength = __webpack_require__(33),
toKey = __webpack_require__(28);

/**

* Checks if `path` exists on `object`.
*
* @private
* @param {Object} object The object to query.
* @param {Array|string} path The path to check.
* @param {Function} hasFunc The function to check properties.
* @returns {boolean} Returns `true` if `path` exists, else `false`.
*/

function hasPath(object, path, hasFunc) {

path = castPath(path, object);

var index = -1,
    length = path.length,
    result = false;

while (++index < length) {
  var key = toKey(path[index]);
  if (!(result = object != null && hasFunc(object, key))) {
    break;
  }
  object = object[key];
}
if (result || ++index != length) {
  return result;
}
length = object == null ? 0 : object.length;
return !!length && isLength(length) && isIndex(key, length) &&
  (isArray(object) || isArguments(object));

}

module.exports = hasPath;

/***/ }), /* 315 */ /***/ (function(module, exports, webpack_require) {

var baseProperty = webpack_require(316),

basePropertyDeep = __webpack_require__(317),
isKey = __webpack_require__(37),
toKey = __webpack_require__(28);

/**

* Creates a function that returns the value at `path` of a given object.
*
* @static
* @memberOf _
* @since 2.4.0
* @category Util
* @param {Array|string} path The path of the property to get.
* @returns {Function} Returns the new accessor function.
* @example
*
* var objects = [
*   { 'a': { 'b': 2 } },
*   { 'a': { 'b': 1 } }
* ];
*
* _.map(objects, _.property('a.b'));
* // => [2, 1]
*
* _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
* // => [1, 2]
*/

function property(path) {

return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);

}

module.exports = property;

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

/**

* The base implementation of `_.property` without support for deep paths.
*
* @private
* @param {string} key The key of the property to get.
* @returns {Function} Returns the new accessor function.
*/

function baseProperty(key) {

return function(object) {
  return object == null ? undefined : object[key];
};

}

module.exports = baseProperty;

/***/ }), /* 317 */ /***/ (function(module, exports, webpack_require) {

var baseGet = webpack_require(193);

/**

* A specialized version of `baseProperty` which supports deep paths.
*
* @private
* @param {Array|string} path The path of the property to get.
* @returns {Function} Returns the new accessor function.
*/

function basePropertyDeep(path) {

return function(object) {
  return baseGet(object, path);
};

}

module.exports = basePropertyDeep;

/***/ }), /* 318 */ /***/ (function(module, exports, webpack_require) {

var baseFindIndex = webpack_require(195),

baseIteratee = __webpack_require__(15),
toInteger = __webpack_require__(319);

/* Built-in method references for those with the same name as other `lodash` methods. */ var nativeMax = Math.max;

/**

* This method is like `_.find` except that it returns the index of the first
* element `predicate` returns truthy for instead of the element itself.
*
* @static
* @memberOf _
* @since 1.1.0
* @category Array
* @param {Array} array The array to inspect.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @param {number} [fromIndex=0] The index to search from.
* @returns {number} Returns the index of the found element, else `-1`.
* @example
*
* var users = [
*   { 'user': 'barney',  'active': false },
*   { 'user': 'fred',    'active': false },
*   { 'user': 'pebbles', 'active': true }
* ];
*
* _.findIndex(users, function(o) { return o.user == 'barney'; });
* // => 0
*
* // The `_.matches` iteratee shorthand.
* _.findIndex(users, { 'user': 'fred', 'active': false });
* // => 1
*
* // The `_.matchesProperty` iteratee shorthand.
* _.findIndex(users, ['active', false]);
* // => 0
*
* // The `_.property` iteratee shorthand.
* _.findIndex(users, 'active');
* // => 2
*/

function findIndex(array, predicate, fromIndex) {

var length = array == null ? 0 : array.length;
if (!length) {
  return -1;
}
var index = fromIndex == null ? 0 : toInteger(fromIndex);
if (index < 0) {
  index = nativeMax(length + index, 0);
}
return baseFindIndex(array, baseIteratee(predicate, 3), index);

}

module.exports = findIndex;

/***/ }), /* 319 */ /***/ (function(module, exports, webpack_require) {

var toFinite = webpack_require(320);

/**

* Converts `value` to an integer.
*
* **Note:** This method is loosely based on
* [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to convert.
* @returns {number} Returns the converted integer.
* @example
*
* _.toInteger(3.2);
* // => 3
*
* _.toInteger(Number.MIN_VALUE);
* // => 0
*
* _.toInteger(Infinity);
* // => 1.7976931348623157e+308
*
* _.toInteger('3.2');
* // => 3
*/

function toInteger(value) {

var result = toFinite(value),
    remainder = result % 1;

return result === result ? (remainder ? result - remainder : result) : 0;

}

module.exports = toInteger;

/***/ }), /* 320 */ /***/ (function(module, exports, webpack_require) {

var toNumber = webpack_require(321);

/** Used as references for various `Number` constants. */ var INFINITY = 1 / 0,

MAX_INTEGER = 1.7976931348623157e+308;

/**

* Converts `value` to a finite number.
*
* @static
* @memberOf _
* @since 4.12.0
* @category Lang
* @param {*} value The value to convert.
* @returns {number} Returns the converted number.
* @example
*
* _.toFinite(3.2);
* // => 3.2
*
* _.toFinite(Number.MIN_VALUE);
* // => 5e-324
*
* _.toFinite(Infinity);
* // => 1.7976931348623157e+308
*
* _.toFinite('3.2');
* // => 3.2
*/

function toFinite(value) {

if (!value) {
  return value === 0 ? value : 0;
}
value = toNumber(value);
if (value === INFINITY || value === -INFINITY) {
  var sign = (value < 0 ? -1 : 1);
  return sign * MAX_INTEGER;
}
return value === value ? value : 0;

}

module.exports = toFinite;

/***/ }), /* 321 */ /***/ (function(module, exports, webpack_require) {

var isObject = webpack_require(14),

isSymbol = __webpack_require__(16);

/** Used as references for various `Number` constants. */ var NAN = 0 / 0;

/** Used to match leading and trailing whitespace. */ var reTrim = /^s+|s+$/g;

/** Used to detect bad signed hexadecimal string values. */ var reIsBadHex = /^[-]0x[0-9a-f]$/i;

/** Used to detect binary string values. */ var reIsBinary = /^0b+$/i;

/** Used to detect octal string values. */ var reIsOctal = /^0o+$/i;

/** Built-in method references without a dependency on `root`. */ var freeParseInt = parseInt;

/**

* Converts `value` to a number.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to process.
* @returns {number} Returns the number.
* @example
*
* _.toNumber(3.2);
* // => 3.2
*
* _.toNumber(Number.MIN_VALUE);
* // => 5e-324
*
* _.toNumber(Infinity);
* // => Infinity
*
* _.toNumber('3.2');
* // => 3.2
*/

function toNumber(value) {

if (typeof value == 'number') {
  return value;
}
if (isSymbol(value)) {
  return NAN;
}
if (isObject(value)) {
  var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
  value = isObject(other) ? (other + '') : other;
}
if (typeof value != 'string') {
  return value === 0 ? value : +value;
}
value = value.replace(reTrim, '');
var isBinary = reIsBinary.test(value);
return (isBinary || reIsOctal.test(value))
  ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
  : (reIsBadHex.test(value) ? NAN : +value);

}

module.exports = toNumber;

/***/ }), /* 322 */ /***/ (function(module, exports, webpack_require) {

var baseGetTag = webpack_require(11),

isArray = __webpack_require__(2),
isObjectLike = __webpack_require__(12);

/** `Object#toString` result references. */ var stringTag = '[object String]';

/**

* Checks if `value` is classified as a `String` primitive or object.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a string, else `false`.
* @example
*
* _.isString('abc');
* // => true
*
* _.isString(1);
* // => false
*/

function isString(value) {

return typeof value == 'string' ||
  (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);

}

module.exports = isString;

/***/ }), /* 323 */ /***/ (function(module, exports, webpack_require) {

var baseOrderBy = webpack_require(324),

isArray = __webpack_require__(2);

/**

* This method is like `_.sortBy` except that it allows specifying the sort
* orders of the iteratees to sort by. If `orders` is unspecified, all values
* are sorted in ascending order. Otherwise, specify an order of "desc" for
* descending or "asc" for ascending sort order of corresponding values.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]
*  The iteratees to sort by.
* @param {string[]} [orders] The sort orders of `iteratees`.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
* @returns {Array} Returns the new sorted array.
* @example
*
* var users = [
*   { 'user': 'fred',   'age': 48 },
*   { 'user': 'barney', 'age': 34 },
*   { 'user': 'fred',   'age': 40 },
*   { 'user': 'barney', 'age': 36 }
* ];
*
* // Sort by `user` in ascending order and by `age` in descending order.
* _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
* // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
*/

function orderBy(collection, iteratees, orders, guard) {

if (collection == null) {
  return [];
}
if (!isArray(iteratees)) {
  iteratees = iteratees == null ? [] : [iteratees];
}
orders = guard ? undefined : orders;
if (!isArray(orders)) {
  orders = orders == null ? [] : [orders];
}
return baseOrderBy(collection, iteratees, orders);

}

module.exports = orderBy;

/***/ }), /* 324 */ /***/ (function(module, exports, webpack_require) {

var arrayMap = webpack_require(38),

baseIteratee = __webpack_require__(15),
baseMap = __webpack_require__(197),
baseSortBy = __webpack_require__(325),
baseUnary = __webpack_require__(179),
compareMultiple = __webpack_require__(326),
identity = __webpack_require__(18);

/**

* The base implementation of `_.orderBy` without param guards.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
* @param {string[]} orders The sort orders of `iteratees`.
* @returns {Array} Returns the new sorted array.
*/

function baseOrderBy(collection, iteratees, orders) {

var index = -1;
iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(baseIteratee));

var result = baseMap(collection, function(value, key, collection) {
  var criteria = arrayMap(iteratees, function(iteratee) {
    return iteratee(value);
  });
  return { 'criteria': criteria, 'index': ++index, 'value': value };
});

return baseSortBy(result, function(object, other) {
  return compareMultiple(object, other, orders);
});

}

module.exports = baseOrderBy;

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

/**

* The base implementation of `_.sortBy` which uses `comparer` to define the
* sort order of `array` and replaces criteria objects with their corresponding
* values.
*
* @private
* @param {Array} array The array to sort.
* @param {Function} comparer The function to define sort order.
* @returns {Array} Returns `array`.
*/

function baseSortBy(array, comparer) {

var length = array.length;

array.sort(comparer);
while (length--) {
  array[length] = array[length].value;
}
return array;

}

module.exports = baseSortBy;

/***/ }), /* 326 */ /***/ (function(module, exports, webpack_require) {

var compareAscending = webpack_require(327);

/**

* Used by `_.orderBy` to compare multiple properties of a value to another
* and stable sort them.
*
* If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
* specify an order of "desc" for descending or "asc" for ascending sort order
* of corresponding values.
*
* @private
* @param {Object} object The object to compare.
* @param {Object} other The other object to compare.
* @param {boolean[]|string[]} orders The order to sort by for each property.
* @returns {number} Returns the sort order indicator for `object`.
*/

function compareMultiple(object, other, orders) {

var index = -1,
    objCriteria = object.criteria,
    othCriteria = other.criteria,
    length = objCriteria.length,
    ordersLength = orders.length;

while (++index < length) {
  var result = compareAscending(objCriteria[index], othCriteria[index]);
  if (result) {
    if (index >= ordersLength) {
      return result;
    }
    var order = orders[index];
    return result * (order == 'desc' ? -1 : 1);
  }
}
// Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
// that causes it, under certain circumstances, to provide the same value for
// `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247
// for more details.
//
// This also ensures a stable sort in V8 and other engines.
// See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
return object.index - other.index;

}

module.exports = compareMultiple;

/***/ }), /* 327 */ /***/ (function(module, exports, webpack_require) {

var isSymbol = webpack_require(16);

/**

* Compares values to sort them in ascending order.
*
* @private
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @returns {number} Returns the sort order indicator for `value`.
*/

function compareAscending(value, other) {

if (value !== other) {
  var valIsDefined = value !== undefined,
      valIsNull = value === null,
      valIsReflexive = value === value,
      valIsSymbol = isSymbol(value);

  var othIsDefined = other !== undefined,
      othIsNull = other === null,
      othIsReflexive = other === other,
      othIsSymbol = isSymbol(other);

  if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
      (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
      (valIsNull && othIsDefined && othIsReflexive) ||
      (!valIsDefined && othIsReflexive) ||
      !valIsReflexive) {
    return 1;
  }
  if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
      (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
      (othIsNull && valIsDefined && valIsReflexive) ||
      (!othIsDefined && valIsReflexive) ||
      !othIsReflexive) {
    return -1;
  }
}
return 0;

}

module.exports = compareAscending;

/***/ }), /* 328 */ /***/ (function(module, exports, webpack_require) {

var arrayMap = webpack_require(38),

baseIteratee = __webpack_require__(15),
baseMap = __webpack_require__(197),
isArray = __webpack_require__(2);

/**

* Creates an array of values by running each element in `collection` thru
* `iteratee`. The iteratee is invoked with three arguments:
* (value, index|key, collection).
*
* Many lodash methods are guarded to work as iteratees for methods like
* `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
*
* The guarded methods are:
* `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
* `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
* `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
* `template`, `trim`, `trimEnd`, `trimStart`, and `words`
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Array} Returns the new mapped array.
* @example
*
* function square(n) {
*   return n * n;
* }
*
* _.map([4, 8], square);
* // => [16, 64]
*
* _.map({ 'a': 4, 'b': 8 }, square);
* // => [16, 64] (iteration order is not guaranteed)
*
* var users = [
*   { 'user': 'barney' },
*   { 'user': 'fred' }
* ];
*
* // The `_.property` iteratee shorthand.
* _.map(users, 'user');
* // => ['barney', 'fred']
*/

function map(collection, iteratee) {

var func = isArray(collection) ? arrayMap : baseMap;
return func(collection, baseIteratee(iteratee, 3));

}

module.exports = map;

/***/ }), /* 329 */ /***/ (function(module, exports, webpack_require) {

var baseIteratee = webpack_require(15),

baseUniq = __webpack_require__(330);

/**

* This method is like `_.uniq` except that it accepts `iteratee` which is
* invoked for each element in `array` to generate the criterion by which
* uniqueness is computed. The order of result values is determined by the
* order they occur in the array. The iteratee is invoked with one argument:
* (value).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to inspect.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {Array} Returns the new duplicate free array.
* @example
*
* _.uniqBy([2.1, 1.2, 2.3], Math.floor);
* // => [2.1, 1.2]
*
* // The `_.property` iteratee shorthand.
* _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
* // => [{ 'x': 1 }, { 'x': 2 }]
*/

function uniqBy(array, iteratee) {

return (array && array.length) ? baseUniq(array, baseIteratee(iteratee, 2)) : [];

}

module.exports = uniqBy;

/***/ }), /* 330 */ /***/ (function(module, exports, webpack_require) {

var SetCache = webpack_require(188),

arrayIncludes = __webpack_require__(331),
arrayIncludesWith = __webpack_require__(335),
cacheHas = __webpack_require__(189),
createSet = __webpack_require__(336),
setToArray = __webpack_require__(36);

/** Used as the size to enable large array optimizations. */ var LARGE_ARRAY_SIZE = 200;

/**

* The base implementation of `_.uniqBy` without support for iteratee shorthands.
*
* @private
* @param {Array} array The array to inspect.
* @param {Function} [iteratee] The iteratee invoked per element.
* @param {Function} [comparator] The comparator invoked per element.
* @returns {Array} Returns the new duplicate free array.
*/

function baseUniq(array, iteratee, comparator) {

var index = -1,
    includes = arrayIncludes,
    length = array.length,
    isCommon = true,
    result = [],
    seen = result;

if (comparator) {
  isCommon = false;
  includes = arrayIncludesWith;
}
else if (length >= LARGE_ARRAY_SIZE) {
  var set = iteratee ? null : createSet(array);
  if (set) {
    return setToArray(set);
  }
  isCommon = false;
  includes = cacheHas;
  seen = new SetCache;
}
else {
  seen = iteratee ? [] : result;
}
outer:
while (++index < length) {
  var value = array[index],
      computed = iteratee ? iteratee(value) : value;

  value = (comparator || value !== 0) ? value : 0;
  if (isCommon && computed === computed) {
    var seenIndex = seen.length;
    while (seenIndex--) {
      if (seen[seenIndex] === computed) {
        continue outer;
      }
    }
    if (iteratee) {
      seen.push(computed);
    }
    result.push(value);
  }
  else if (!includes(seen, computed, comparator)) {
    if (seen !== result) {
      seen.push(computed);
    }
    result.push(value);
  }
}
return result;

}

module.exports = baseUniq;

/***/ }), /* 331 */ /***/ (function(module, exports, webpack_require) {

var baseIndexOf = webpack_require(332);

/**

* A specialized version of `_.includes` for arrays without support for
* specifying an index to search from.
*
* @private
* @param {Array} [array] The array to inspect.
* @param {*} target The value to search for.
* @returns {boolean} Returns `true` if `target` is found, else `false`.
*/

function arrayIncludes(array, value) {

var length = array == null ? 0 : array.length;
return !!length && baseIndexOf(array, value, 0) > -1;

}

module.exports = arrayIncludes;

/***/ }), /* 332 */ /***/ (function(module, exports, webpack_require) {

var baseFindIndex = webpack_require(195),

baseIsNaN = __webpack_require__(333),
strictIndexOf = __webpack_require__(334);

/**

* The base implementation of `_.indexOf` without `fromIndex` bounds checks.
*
* @private
* @param {Array} array The array to inspect.
* @param {*} value The value to search for.
* @param {number} fromIndex The index to search from.
* @returns {number} Returns the index of the matched value, else `-1`.
*/

function baseIndexOf(array, value, fromIndex) {

return value === value
  ? strictIndexOf(array, value, fromIndex)
  : baseFindIndex(array, baseIsNaN, fromIndex);

}

module.exports = baseIndexOf;

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

/**

* The base implementation of `_.isNaN` without support for number objects.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
*/

function baseIsNaN(value) {

return value !== value;

}

module.exports = baseIsNaN;

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

/**

* A specialized version of `_.indexOf` which performs strict equality
* comparisons of values, i.e. `===`.
*
* @private
* @param {Array} array The array to inspect.
* @param {*} value The value to search for.
* @param {number} fromIndex The index to search from.
* @returns {number} Returns the index of the matched value, else `-1`.
*/

function strictIndexOf(array, value, fromIndex) {

var index = fromIndex - 1,
    length = array.length;

while (++index < length) {
  if (array[index] === value) {
    return index;
  }
}
return -1;

}

module.exports = strictIndexOf;

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

/**

* This function is like `arrayIncludes` except that it accepts a comparator.
*
* @private
* @param {Array} [array] The array to inspect.
* @param {*} target The value to search for.
* @param {Function} comparator The comparator invoked per element.
* @returns {boolean} Returns `true` if `target` is found, else `false`.
*/

function arrayIncludesWith(array, value, comparator) {

var index = -1,
    length = array == null ? 0 : array.length;

while (++index < length) {
  if (comparator(value, array[index])) {
    return true;
  }
}
return false;

}

module.exports = arrayIncludesWith;

/***/ }), /* 336 */ /***/ (function(module, exports, webpack_require) {

var Set = webpack_require(190),

noop = __webpack_require__(337),
setToArray = __webpack_require__(36);

/** Used as references for various `Number` constants. */ var INFINITY = 1 / 0;

/**

* Creates a set object of `values`.
*
* @private
* @param {Array} values The values to add to the set.
* @returns {Object} Returns the new set.
*/

var createSet = !(Set && (1 / setToArray(new Set())[1]) == INFINITY) ? noop : function(values) {

return new Set(values);

};

module.exports = createSet;

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

/**

* This method returns `undefined`.
*
* @static
* @memberOf _
* @since 2.3.0
* @category Util
* @example
*
* _.times(2, _.noop);
* // => [undefined, undefined]
*/

function noop() {

// No operation performed.

}

module.exports = noop;

/***/ }), /* 338 */ /***/ (function(module, exports, webpack_require) {

var baseExtremum = webpack_require(339),

baseGt = __webpack_require__(340),
baseIteratee = __webpack_require__(15);

/**

* This method is like `_.max` except that it accepts `iteratee` which is
* invoked for each element in `array` to generate the criterion by which
* the value is ranked. The iteratee is invoked with one argument: (value).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Math
* @param {Array} array The array to iterate over.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {*} Returns the maximum value.
* @example
*
* var objects = [{ 'n': 1 }, { 'n': 2 }];
*
* _.maxBy(objects, function(o) { return o.n; });
* // => { 'n': 2 }
*
* // The `_.property` iteratee shorthand.
* _.maxBy(objects, 'n');
* // => { 'n': 2 }
*/

function maxBy(array, iteratee) {

return (array && array.length)
  ? baseExtremum(array, baseIteratee(iteratee, 2), baseGt)
  : undefined;

}

module.exports = maxBy;

/***/ }), /* 339 */ /***/ (function(module, exports, webpack_require) {

var isSymbol = webpack_require(16);

/**

* The base implementation of methods like `_.max` and `_.min` which accepts a
* `comparator` to determine the extremum value.
*
* @private
* @param {Array} array The array to iterate over.
* @param {Function} iteratee The iteratee invoked per iteration.
* @param {Function} comparator The comparator used to compare values.
* @returns {*} Returns the extremum value.
*/

function baseExtremum(array, iteratee, comparator) {

var index = -1,
    length = array.length;

while (++index < length) {
  var value = array[index],
      current = iteratee(value);

  if (current != null && (computed === undefined
        ? (current === current && !isSymbol(current))
        : comparator(current, computed)
      )) {
    var computed = current,
        result = value;
  }
}
return result;

}

module.exports = baseExtremum;

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

/**

* The base implementation of `_.gt` which doesn't coerce arguments.
*
* @private
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @returns {boolean} Returns `true` if `value` is greater than `other`,
*  else `false`.
*/

function baseGt(value, other) {

return value > other;

}

module.exports = baseGt;

/***/ }) /******/ ])[“default”]; });