(function () {
/* Imports */
var Meteor = Package.meteor.Meteor;
/* Package-scope variables */
var babelHelpers;
(function(){
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// packages/babel-runtime/babel-runtime.js //
// //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
var hasOwn = Object.prototype.hasOwnProperty; // 1
// 2
function canDefineNonEnumerableProperties() { // 3
var testObj = {}; // 4
var testPropName = "t"; // 5
// 6
try { // 7
Object.defineProperty(testObj, testPropName, { // 8
enumerable: false, // 9
value: testObj // 10
}); // 11
// 12
for (var k in testObj) { // 13
if (k === testPropName) { // 14
return false; // 15
} // 16
} // 17
} catch (e) { // 18
return false; // 19
} // 20
// 21
return testObj[testPropName] === testObj; // 22
} // 23
// 24
// The name `babelHelpers` is hard-coded in Babel. Otherwise we would make it // 25
// something capitalized and more descriptive, like `BabelRuntime`. // 26
babelHelpers = { // 27
// Meteor-specific runtime helper for wrapping the object of for-in // 28
// loops, so that inherited Array methods defined by es5-shim can be // 29
// ignored in browsers where they cannot be defined as non-enumerable. // 30
sanitizeForInObject: canDefineNonEnumerableProperties() // 31
? function (value) { return value; } // 32
: function (obj) { // 33
if (Array.isArray(obj)) { // 34
var newObj = {}; // 35
var keys = Object.keys(obj); // 36
var keyCount = keys.length; // 37
for (var i = 0; i < keyCount; ++i) { // 38
var key = keys[i]; // 39
newObj[key] = obj[key]; // 40
} // 41
return newObj; // 42
} // 43
// 44
return obj; // 45
}, // 46
// 47
// es6.templateLiterals // 48
// Constructs the object passed to the tag function in a tagged // 49
// template literal. // 50
taggedTemplateLiteralLoose: function (strings, raw) { // 51
// Babel's own version of this calls Object.freeze on `strings` and // 52
// `strings.raw`, but it doesn't seem worth the compatibility and // 53
// performance concerns. If you're writing code against this helper, // 54
// don't add properties to these objects. // 55
strings.raw = raw; // 56
return strings; // 57
}, // 58
// 59
// es6.classes // 60
// Checks that a class constructor is being called with `new`, and throws // 61
// an error if it is not. // 62
classCallCheck: function (instance, Constructor) { // 63
if (!(instance instanceof Constructor)) { // 64
throw new TypeError("Cannot call a class as a function"); // 65
} // 66
}, // 67
// 68
// es6.classes // 69
inherits: function (subClass, superClass) { // 70
if (typeof superClass !== "function" && superClass !== null) { // 71
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
} // 73
// 74
if (superClass) { // 75
if (Object.create) { // 76
// All but IE 8 // 77
subClass.prototype = Object.create(superClass.prototype, { // 78
constructor: { // 79
value: subClass, // 80
enumerable: false, // 81
writable: true, // 82
configurable: true // 83
} // 84
}); // 85
} else { // 86
// IE 8 path. Slightly worse for modern browsers, because `constructor` // 87
// is enumerable and shows up in the inspector unnecessarily. // 88
// It's not an "own" property of any instance though. // 89
// // 90
// For correctness when writing code, // 91
// don't enumerate all the own-and-inherited properties of an instance // 92
// of a class and expect not to find `constructor` (but who does that?). // 93
var F = function () { // 94
this.constructor = subClass; // 95
}; // 96
F.prototype = superClass.prototype; // 97
subClass.prototype = new F(); // 98
} // 99
// 100
// For modern browsers, this would be `subClass.__proto__ = superClass`, // 101
// but IE <=10 don't support `__proto__`, and in this case the difference // 102
// would be detectable; code that works in modern browsers could easily // 103
// fail on IE 8 if we ever used the `__proto__` trick. // 104
// // 105
// There's no perfect way to make static methods inherited if they are // 106
// assigned after declaration of the classes. The best we can do is // 107
// to copy them. In other words, when you write `class Foo // 108
// extends Bar`, we copy the static methods from Bar onto Foo, but future // 109
// ones are not copied. // 110
// // 111
// For correctness when writing code, don't add static methods to a class // 112
// after you subclass it. // 113
for (var k in superClass) { // 114
if (hasOwn.call(superClass, k)) { // 115
subClass[k] = superClass[k]; // 116
} // 117
} // 118
} // 119
}, // 120
// 121
createClass: (function () { // 122
var hasDefineProperty = false; // 123
try { // 124
// IE 8 has a broken Object.defineProperty, so feature-test by // 125
// trying to call it. // 126
Object.defineProperty({}, 'x', {}); // 127
hasDefineProperty = true; // 128
} catch (e) {} // 129
// 130
function defineProperties(target, props) { // 131
for (var i = 0; i < props.length; i++) { // 132
var descriptor = props[i]; // 133
descriptor.enumerable = descriptor.enumerable || false; // 134
descriptor.configurable = true; // 135
if ("value" in descriptor) descriptor.writable = true; // 136
Object.defineProperty(target, descriptor.key, descriptor); // 137
} // 138
} // 139
// 140
return function (Constructor, protoProps, staticProps) { // 141
if (! hasDefineProperty) { // 142
// e.g. `class Foo { get bar() {} }`. If you try to use getters and // 143
// setters in IE 8, you will get a big nasty error, with or without // 144
// Babel. I don't know of any other syntax features besides getters // 145
// and setters that will trigger this error. // 146
throw new Error( // 147
"Your browser does not support this type of class property. " + // 148
"For example, Internet Explorer 8 does not support getters and " + // 149
"setters."); // 150
} // 151
// 152
if (protoProps) defineProperties(Constructor.prototype, protoProps); // 153
if (staticProps) defineProperties(Constructor, staticProps); // 154
return Constructor; // 155
}; // 156
})(), // 157
// 158
// es7.objectRestSpread and react (JSX) // 159
_extends: Object.assign || (function (target) { // 160
for (var i = 1; i < arguments.length; i++) { // 161
var source = arguments[i]; // 162
for (var key in source) { // 163
if (hasOwn.call(source, key)) { // 164
target[key] = source[key]; // 165
} // 166
} // 167
} // 168
return target; // 169
}), // 170
// 171
// es6.destructuring // 172
objectWithoutProperties: function (obj, keys) { // 173
var target = {}; // 174
outer: for (var i in obj) { // 175
if (! hasOwn.call(obj, i)) continue; // 176
for (var j = 0; j < keys.length; j++) { // 177
if (keys[j] === i) continue outer; // 178
} // 179
target[i] = obj[i]; // 180
} // 181
return target; // 182
}, // 183
// 184
// es6.destructuring // 185
objectDestructuringEmpty: function (obj) { // 186
if (obj == null) throw new TypeError("Cannot destructure undefined"); // 187
}, // 188
// 189
// es6.spread // 190
bind: Function.prototype.bind || (function () { // 191
var isCallable = function (value) { return typeof value === 'function'; }; // 192
var $Object = Object; // 193
var to_string = Object.prototype.toString; // 194
var array_slice = Array.prototype.slice; // 195
var array_concat = Array.prototype.concat; // 196
var array_push = Array.prototype.push; // 197
var max = Math.max; // 198
var Empty = function Empty() {}; // 199
// 200
// Copied from es5-shim.js (3ac7942). See original for more comments. // 201
return function bind(that) { // 202
var target = this; // 203
if (!isCallable(target)) { // 204
throw new TypeError('Function.prototype.bind called on incompatible ' + target); // 205
} // 206
// 207
var args = array_slice.call(arguments, 1); // 208
// 209
var bound; // 210
var binder = function () { // 211
// 212
if (this instanceof bound) { // 213
var result = target.apply( // 214
this, // 215
array_concat.call(args, array_slice.call(arguments)) // 216
); // 217
if ($Object(result) === result) { // 218
return result; // 219
} // 220
return this; // 221
} else { // 222
return target.apply( // 223
that, // 224
array_concat.call(args, array_slice.call(arguments)) // 225
); // 226
} // 227
}; // 228
// 229
var boundLength = max(0, target.length - args.length); // 230
// 231
var boundArgs = []; // 232
for (var i = 0; i < boundLength; i++) { // 233
array_push.call(boundArgs, '$' + i); // 234
} // 235
// 236
// Create a Function from source code so that it has the right `.length`. // 237
// Probably not important for Babel. This code violates CSPs that ban // 238
// `eval`, but the browsers that need this polyfill don't have CSP! // 239
bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this, arguments); }')(binder);
// 241
if (target.prototype) { // 242
Empty.prototype = target.prototype; // 243
bound.prototype = new Empty(); // 244
Empty.prototype = null; // 245
} // 246
// 247
return bound; // 248
}; // 249
// 250
})(), // 251
// 252
slice: Array.prototype.slice // 253
}; // 254
// 255
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
}).call(this);
/* Exports */
if (typeof Package === 'undefined') Package = {};
Package['babel-runtime'] = {
babelHelpers: babelHelpers
};
})();
//# sourceMappingURL=babel-runtime.js.map