(function e(t,n,r){function s(o,u){if(!n){if(!t){var a=typeof require==“function”&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(“Cannot find module '”o“'”);throw f.code=“MODULE_NOT_FOUND”,f}var l=n={exports:{}};t[0].call(l.exports,function(e){var n=t[1];return s(n?n:e)},l,l.exports,e,t,n,r)}return n.exports}var i=typeof require==“function”&&require;for(var o=0;o);return s})({1:[function(require,module,exports){ 'use strict';

var keys = require('object-keys').shim(); delete keys.shim;

var assign = require('./');

module.exports = assign.shim();

delete assign.shim;

},{“./”:3,“object-keys”:9}],2:[function(require,module,exports){ 'use strict';

// modified from github.com/es-shims/es6-shim var keys = require('object-keys'); var bind = require('function-bind'); var canBeObject = function (obj) {

return typeof obj !== 'undefined' && obj !== null;

}; var hasSymbols = require('has-symbols/shams')(); var toObject = Object; var push = bind.call(Function.call, Array.prototype.push); var propIsEnumerable = bind.call(Function.call, Object.prototype.propertyIsEnumerable); var originalGetSymbols = hasSymbols ? Object.getOwnPropertySymbols : null;

module.exports = function assign(target, source1) {

if (!canBeObject(target)) { throw new TypeError('target must be an object'); }
var objTarget = toObject(target);
var s, source, i, props, syms, value, key;
for (s = 1; s < arguments.length; ++s) {
        source = toObject(arguments[s]);
        props = keys(source);
        var getSymbols = hasSymbols && (Object.getOwnPropertySymbols || originalGetSymbols);
        if (getSymbols) {
                syms = getSymbols(source);
                for (i = 0; i < syms.length; ++i) {
                        key = syms[i];
                        if (propIsEnumerable(source, key)) {
                                push(props, key);
                        }
                }
        }
        for (i = 0; i < props.length; ++i) {
                key = props[i];
                value = source[key];
                if (propIsEnumerable(source, key)) {
                        objTarget[key] = value;
                }
        }
}
return objTarget;

};

},{“function-bind”:7,“has-symbols/shams”:8,“object-keys”:9}],3:[function(require,module,exports){ 'use strict';

var defineProperties = require('define-properties');

var implementation = require('./implementation'); var getPolyfill = require('./polyfill'); var shim = require('./shim');

var polyfill = getPolyfill();

defineProperties(polyfill, {

getPolyfill: getPolyfill,
implementation: implementation,
shim: shim

});

module.exports = polyfill;

},{“./implementation”:2,“./polyfill”:11,“./shim”:12,“define-properties”:4}],4:[function(require,module,exports){ 'use strict';

var keys = require('object-keys'); var foreach = require('foreach'); var hasSymbols = typeof Symbol === 'function' && typeof Symbol() === 'symbol';

var toStr = Object.prototype.toString;

var isFunction = function (fn) {

return typeof fn === 'function' && toStr.call(fn) === '[object Function]';

};

var arePropertyDescriptorsSupported = function () {

var obj = {};
try {
        Object.defineProperty(obj, 'x', { enumerable: false, value: obj });
/* eslint-disable no-unused-vars, no-restricted-syntax */
for (var _ in obj) { return false; }
/* eslint-enable no-unused-vars, no-restricted-syntax */
        return obj.x === obj;
} catch (e) { /* this is IE 8. */
        return false;
}

}; var supportsDescriptors = Object.defineProperty && arePropertyDescriptorsSupported();

var defineProperty = function (object, name, value, predicate) {

if (name in object && (!isFunction(predicate) || !predicate())) {
        return;
}
if (supportsDescriptors) {
        Object.defineProperty(object, name, {
                configurable: true,
                enumerable: false,
                value: value,
                writable: true
        });
} else {
        object[name] = value;
}

};

var defineProperties = function (object, map) {

var predicates = arguments.length > 2 ? arguments[2] : {};
var props = keys(map);
if (hasSymbols) {
        props = props.concat(Object.getOwnPropertySymbols(map));
}
foreach(props, function (name) {
        defineProperty(object, name, map[name], predicates[name]);
});

};

defineProperties.supportsDescriptors = !!supportsDescriptors;

module.exports = defineProperties;

},{“foreach”:5,“object-keys”:9}],5:[function(require,module,exports){

var hasOwn = Object.prototype.hasOwnProperty; var toString = Object.prototype.toString;

module.exports = function forEach (obj, fn, ctx) {

if (toString.call(fn) !== '[object Function]') {
    throw new TypeError('iterator must be a function');
}
var l = obj.length;
if (l === +l) {
    for (var i = 0; i < l; i++) {
        fn.call(ctx, obj[i], i, obj);
    }
} else {
    for (var k in obj) {
        if (hasOwn.call(obj, k)) {
            fn.call(ctx, obj[k], k, obj);
        }
    }
}

};

},{}],6:[function(require,module,exports){ 'use strict';

/* eslint no-invalid-this: 1 */

var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible '; var slice = Array.prototype.slice; var toStr = Object.prototype.toString; var funcType = '[object Function]';

module.exports = function bind(that) {

var target = this;
if (typeof target !== 'function' || toStr.call(target) !== funcType) {
    throw new TypeError(ERROR_MESSAGE + target);
}
var args = slice.call(arguments, 1);

var bound;
var binder = function () {
    if (this instanceof bound) {
        var result = target.apply(
            this,
            args.concat(slice.call(arguments))
        );
        if (Object(result) === result) {
            return result;
        }
        return this;
    } else {
        return target.apply(
            that,
            args.concat(slice.call(arguments))
        );
    }
};

var boundLength = Math.max(0, target.length - args.length);
var boundArgs = [];
for (var i = 0; i < boundLength; i++) {
    boundArgs.push('$' + i);
}

bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);

if (target.prototype) {
    var Empty = function Empty() {};
    Empty.prototype = target.prototype;
    bound.prototype = new Empty();
    Empty.prototype = null;
}

return bound;

};

},{}],7:[function(require,module,exports){ 'use strict';

var implementation = require('./implementation');

module.exports = Function.prototype.bind || implementation;

},{“./implementation”:6}],8:[function(require,module,exports){ 'use strict';

/* eslint complexity: [2, 17], max-statements: [2, 33] */ module.exports = function hasSymbols() {

if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
if (typeof Symbol.iterator === 'symbol') { return true; }

var obj = {};
var sym = Symbol('test');
var symObj = Object(sym);
if (typeof sym === 'string') { return false; }

if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }

// temp disabled per https://github.com/ljharb/object.assign/issues/17
// if (sym instanceof Symbol) { return false; }
// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
// if (!(symObj instanceof Symbol)) { return false; }

// if (typeof Symbol.prototype.toString !== 'function') { return false; }
// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }

var symVal = 42;
obj[sym] = symVal;
for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax
if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }

if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }

var syms = Object.getOwnPropertySymbols(obj);
if (syms.length !== 1 || syms[0] !== sym) { return false; }

if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }

if (typeof Object.getOwnPropertyDescriptor === 'function') {
        var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
        if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
}

return true;

};

},{}],9:[function(require,module,exports){ 'use strict';

// modified from github.com/es-shims/es5-shim var has = Object.prototype.hasOwnProperty; var toStr = Object.prototype.toString; var slice = Array.prototype.slice; var isArgs = require('./isArguments'); var isEnumerable = Object.prototype.propertyIsEnumerable; var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString'); var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype'); var dontEnums = [

'toString',
'toLocaleString',
'valueOf',
'hasOwnProperty',
'isPrototypeOf',
'propertyIsEnumerable',
'constructor'

]; var equalsConstructorPrototype = function (o) {

var ctor = o.constructor;
return ctor && ctor.prototype === o;

}; var excludedKeys = {

$console: true,
$external: true,
$frame: true,
$frameElement: true,
$frames: true,
$innerHeight: true,
$innerWidth: true,
$outerHeight: true,
$outerWidth: true,
$pageXOffset: true,
$pageYOffset: true,
$parent: true,
$scrollLeft: true,
$scrollTop: true,
$scrollX: true,
$scrollY: true,
$self: true,
$webkitIndexedDB: true,
$webkitStorageInfo: true,
$window: true

}; var hasAutomationEqualityBug = (function () {

/* global window */
if (typeof window === 'undefined') { return false; }
for (var k in window) {
        try {
                if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
                        try {
                                equalsConstructorPrototype(window[k]);
                        } catch (e) {
                                return true;
                        }
                }
        } catch (e) {
                return true;
        }
}
return false;

}()); var equalsConstructorPrototypeIfNotBuggy = function (o) {

/* global window */
if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
        return equalsConstructorPrototype(o);
}
try {
        return equalsConstructorPrototype(o);
} catch (e) {
        return false;
}

};

var keysShim = function keys(object) {

var isObject = object !== null && typeof object === 'object';
var isFunction = toStr.call(object) === '[object Function]';
var isArguments = isArgs(object);
var isString = isObject && toStr.call(object) === '[object String]';
var theKeys = [];

if (!isObject && !isFunction && !isArguments) {
        throw new TypeError('Object.keys called on a non-object');
}

var skipProto = hasProtoEnumBug && isFunction;
if (isString && object.length > 0 && !has.call(object, 0)) {
        for (var i = 0; i < object.length; ++i) {
                theKeys.push(String(i));
        }
}

if (isArguments && object.length > 0) {
        for (var j = 0; j < object.length; ++j) {
                theKeys.push(String(j));
        }
} else {
        for (var name in object) {
                if (!(skipProto && name === 'prototype') && has.call(object, name)) {
                        theKeys.push(String(name));
                }
        }
}

if (hasDontEnumBug) {
        var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);

        for (var k = 0; k < dontEnums.length; ++k) {
                if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
                        theKeys.push(dontEnums[k]);
                }
        }
}
return theKeys;

};

keysShim.shim = function shimObjectKeys() {

if (Object.keys) {
        var keysWorksWithArguments = (function () {
                // Safari 5.0 bug
                return (Object.keys(arguments) || '').length === 2;
        }(1, 2));
        if (!keysWorksWithArguments) {
                var originalKeys = Object.keys;
                Object.keys = function keys(object) {
                        if (isArgs(object)) {
                                return originalKeys(slice.call(object));
                        } else {
                                return originalKeys(object);
                        }
                };
        }
} else {
        Object.keys = keysShim;
}
return Object.keys || keysShim;

};

module.exports = keysShim;

},{“./isArguments”:10}],10:[function(require,module,exports){ 'use strict';

var toStr = Object.prototype.toString;

module.exports = function isArguments(value) {

var str = toStr.call(value);
var isArgs = str === '[object Arguments]';
if (!isArgs) {
        isArgs = str !== '[object Array]' &&
                value !== null &&
                typeof value === 'object' &&
                typeof value.length === 'number' &&
                value.length >= 0 &&
                toStr.call(value.callee) === '[object Function]';
}
return isArgs;

};

},{}],11:[function(require,module,exports){ 'use strict';

var implementation = require('./implementation');

var lacksProperEnumerationOrder = function () {

if (!Object.assign) {
        return false;
}
// v8, specifically in node 4.x, has a bug with incorrect property enumeration order
// note: this does not detect the bug unless there's 20 characters
var str = 'abcdefghijklmnopqrst';
var letters = str.split('');
var map = {};
for (var i = 0; i < letters.length; ++i) {
        map[letters[i]] = letters[i];
}
var obj = Object.assign({}, map);
var actual = '';
for (var k in obj) {
        actual += k;
}
return str !== actual;

};

var assignHasPendingExceptions = function () {

if (!Object.assign || !Object.preventExtensions) {
        return false;
}
// Firefox 37 still has "pending exception" logic in its Object.assign implementation,
// which is 72% slower than our shim, and Firefox 40's native implementation.
var thrower = Object.preventExtensions({ 1: 2 });
try {
        Object.assign(thrower, 'xy');
} catch (e) {
        return thrower[1] === 'y';
}
return false;

};

module.exports = function getPolyfill() {

if (!Object.assign) {
        return implementation;
}
if (lacksProperEnumerationOrder()) {
        return implementation;
}
if (assignHasPendingExceptions()) {
        return implementation;
}
return Object.assign;

};

},{“./implementation”:2}],12:[function(require,module,exports){ 'use strict';

var define = require('define-properties'); var getPolyfill = require('./polyfill');

module.exports = function shimAssign() {

var polyfill = getPolyfill();
define(
        Object,
        { assign: polyfill },
        { assign: function () { return Object.assign !== polyfill; } }
);
return polyfill;

};

},{“./polyfill”:11,“define-properties”:4}]},{},[1]);