You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
492 lines
14 KiB
492 lines
14 KiB
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({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 https://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 https://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]);
|