2566 lines
78 KiB
JavaScript
2566 lines
78 KiB
JavaScript
(function(global) {
|
|
'use strict';
|
|
if (global.$traceurRuntime) {
|
|
return;
|
|
}
|
|
var $Object = Object;
|
|
var $TypeError = TypeError;
|
|
var $create = $Object.create;
|
|
var $defineProperties = $Object.defineProperties;
|
|
var $defineProperty = $Object.defineProperty;
|
|
var $freeze = $Object.freeze;
|
|
var $getOwnPropertyDescriptor = $Object.getOwnPropertyDescriptor;
|
|
var $getOwnPropertyNames = $Object.getOwnPropertyNames;
|
|
var $keys = $Object.keys;
|
|
var $hasOwnProperty = $Object.prototype.hasOwnProperty;
|
|
var $toString = $Object.prototype.toString;
|
|
var $preventExtensions = Object.preventExtensions;
|
|
var $seal = Object.seal;
|
|
var $isExtensible = Object.isExtensible;
|
|
function nonEnum(value) {
|
|
return {
|
|
configurable: true,
|
|
enumerable: false,
|
|
value: value,
|
|
writable: true
|
|
};
|
|
}
|
|
var method = nonEnum;
|
|
var counter = 0;
|
|
function newUniqueString() {
|
|
return '__$' + Math.floor(Math.random() * 1e9) + '$' + ++counter + '$__';
|
|
}
|
|
var symbolInternalProperty = newUniqueString();
|
|
var symbolDescriptionProperty = newUniqueString();
|
|
var symbolDataProperty = newUniqueString();
|
|
var symbolValues = $create(null);
|
|
var privateNames = $create(null);
|
|
function isPrivateName(s) {
|
|
return privateNames[s];
|
|
}
|
|
function createPrivateName() {
|
|
var s = newUniqueString();
|
|
privateNames[s] = true;
|
|
return s;
|
|
}
|
|
function isShimSymbol(symbol) {
|
|
return typeof symbol === 'object' && symbol instanceof SymbolValue;
|
|
}
|
|
function typeOf(v) {
|
|
if (isShimSymbol(v))
|
|
return 'symbol';
|
|
return typeof v;
|
|
}
|
|
function Symbol(description) {
|
|
var value = new SymbolValue(description);
|
|
if (!(this instanceof Symbol))
|
|
return value;
|
|
throw new TypeError('Symbol cannot be new\'ed');
|
|
}
|
|
$defineProperty(Symbol.prototype, 'constructor', nonEnum(Symbol));
|
|
$defineProperty(Symbol.prototype, 'toString', method(function() {
|
|
var symbolValue = this[symbolDataProperty];
|
|
if (!getOption('symbols'))
|
|
return symbolValue[symbolInternalProperty];
|
|
if (!symbolValue)
|
|
throw TypeError('Conversion from symbol to string');
|
|
var desc = symbolValue[symbolDescriptionProperty];
|
|
if (desc === undefined)
|
|
desc = '';
|
|
return 'Symbol(' + desc + ')';
|
|
}));
|
|
$defineProperty(Symbol.prototype, 'valueOf', method(function() {
|
|
var symbolValue = this[symbolDataProperty];
|
|
if (!symbolValue)
|
|
throw TypeError('Conversion from symbol to string');
|
|
if (!getOption('symbols'))
|
|
return symbolValue[symbolInternalProperty];
|
|
return symbolValue;
|
|
}));
|
|
function SymbolValue(description) {
|
|
var key = newUniqueString();
|
|
$defineProperty(this, symbolDataProperty, {value: this});
|
|
$defineProperty(this, symbolInternalProperty, {value: key});
|
|
$defineProperty(this, symbolDescriptionProperty, {value: description});
|
|
freeze(this);
|
|
symbolValues[key] = this;
|
|
}
|
|
$defineProperty(SymbolValue.prototype, 'constructor', nonEnum(Symbol));
|
|
$defineProperty(SymbolValue.prototype, 'toString', {
|
|
value: Symbol.prototype.toString,
|
|
enumerable: false
|
|
});
|
|
$defineProperty(SymbolValue.prototype, 'valueOf', {
|
|
value: Symbol.prototype.valueOf,
|
|
enumerable: false
|
|
});
|
|
var hashProperty = createPrivateName();
|
|
var hashPropertyDescriptor = {value: undefined};
|
|
var hashObjectProperties = {
|
|
hash: {value: undefined},
|
|
self: {value: undefined}
|
|
};
|
|
var hashCounter = 0;
|
|
function getOwnHashObject(object) {
|
|
var hashObject = object[hashProperty];
|
|
if (hashObject && hashObject.self === object)
|
|
return hashObject;
|
|
if ($isExtensible(object)) {
|
|
hashObjectProperties.hash.value = hashCounter++;
|
|
hashObjectProperties.self.value = object;
|
|
hashPropertyDescriptor.value = $create(null, hashObjectProperties);
|
|
$defineProperty(object, hashProperty, hashPropertyDescriptor);
|
|
return hashPropertyDescriptor.value;
|
|
}
|
|
return undefined;
|
|
}
|
|
function freeze(object) {
|
|
getOwnHashObject(object);
|
|
return $freeze.apply(this, arguments);
|
|
}
|
|
function preventExtensions(object) {
|
|
getOwnHashObject(object);
|
|
return $preventExtensions.apply(this, arguments);
|
|
}
|
|
function seal(object) {
|
|
getOwnHashObject(object);
|
|
return $seal.apply(this, arguments);
|
|
}
|
|
freeze(SymbolValue.prototype);
|
|
function isSymbolString(s) {
|
|
return symbolValues[s] || privateNames[s];
|
|
}
|
|
function toProperty(name) {
|
|
if (isShimSymbol(name))
|
|
return name[symbolInternalProperty];
|
|
return name;
|
|
}
|
|
function removeSymbolKeys(array) {
|
|
var rv = [];
|
|
for (var i = 0; i < array.length; i++) {
|
|
if (!isSymbolString(array[i])) {
|
|
rv.push(array[i]);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
function getOwnPropertyNames(object) {
|
|
return removeSymbolKeys($getOwnPropertyNames(object));
|
|
}
|
|
function keys(object) {
|
|
return removeSymbolKeys($keys(object));
|
|
}
|
|
function getOwnPropertySymbols(object) {
|
|
var rv = [];
|
|
var names = $getOwnPropertyNames(object);
|
|
for (var i = 0; i < names.length; i++) {
|
|
var symbol = symbolValues[names[i]];
|
|
if (symbol) {
|
|
rv.push(symbol);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
function getOwnPropertyDescriptor(object, name) {
|
|
return $getOwnPropertyDescriptor(object, toProperty(name));
|
|
}
|
|
function hasOwnProperty(name) {
|
|
return $hasOwnProperty.call(this, toProperty(name));
|
|
}
|
|
function getOption(name) {
|
|
return global.traceur && global.traceur.options[name];
|
|
}
|
|
function defineProperty(object, name, descriptor) {
|
|
if (isShimSymbol(name)) {
|
|
name = name[symbolInternalProperty];
|
|
}
|
|
$defineProperty(object, name, descriptor);
|
|
return object;
|
|
}
|
|
function polyfillObject(Object) {
|
|
$defineProperty(Object, 'defineProperty', {value: defineProperty});
|
|
$defineProperty(Object, 'getOwnPropertyNames', {value: getOwnPropertyNames});
|
|
$defineProperty(Object, 'getOwnPropertyDescriptor', {value: getOwnPropertyDescriptor});
|
|
$defineProperty(Object.prototype, 'hasOwnProperty', {value: hasOwnProperty});
|
|
$defineProperty(Object, 'freeze', {value: freeze});
|
|
$defineProperty(Object, 'preventExtensions', {value: preventExtensions});
|
|
$defineProperty(Object, 'seal', {value: seal});
|
|
$defineProperty(Object, 'keys', {value: keys});
|
|
}
|
|
function exportStar(object) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var names = $getOwnPropertyNames(arguments[i]);
|
|
for (var j = 0; j < names.length; j++) {
|
|
var name = names[j];
|
|
if (isSymbolString(name))
|
|
continue;
|
|
(function(mod, name) {
|
|
$defineProperty(object, name, {
|
|
get: function() {
|
|
return mod[name];
|
|
},
|
|
enumerable: true
|
|
});
|
|
})(arguments[i], names[j]);
|
|
}
|
|
}
|
|
return object;
|
|
}
|
|
function isObject(x) {
|
|
return x != null && (typeof x === 'object' || typeof x === 'function');
|
|
}
|
|
function toObject(x) {
|
|
if (x == null)
|
|
throw $TypeError();
|
|
return $Object(x);
|
|
}
|
|
function checkObjectCoercible(argument) {
|
|
if (argument == null) {
|
|
throw new TypeError('Value cannot be converted to an Object');
|
|
}
|
|
return argument;
|
|
}
|
|
function polyfillSymbol(global, Symbol) {
|
|
if (!global.Symbol) {
|
|
global.Symbol = Symbol;
|
|
Object.getOwnPropertySymbols = getOwnPropertySymbols;
|
|
}
|
|
if (!global.Symbol.iterator) {
|
|
global.Symbol.iterator = Symbol('Symbol.iterator');
|
|
}
|
|
}
|
|
function setupGlobals(global) {
|
|
polyfillSymbol(global, Symbol);
|
|
global.Reflect = global.Reflect || {};
|
|
global.Reflect.global = global.Reflect.global || global;
|
|
polyfillObject(global.Object);
|
|
}
|
|
setupGlobals(global);
|
|
global.$traceurRuntime = {
|
|
checkObjectCoercible: checkObjectCoercible,
|
|
createPrivateName: createPrivateName,
|
|
defineProperties: $defineProperties,
|
|
defineProperty: $defineProperty,
|
|
exportStar: exportStar,
|
|
getOwnHashObject: getOwnHashObject,
|
|
getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
|
|
getOwnPropertyNames: $getOwnPropertyNames,
|
|
isObject: isObject,
|
|
isPrivateName: isPrivateName,
|
|
isSymbolString: isSymbolString,
|
|
keys: $keys,
|
|
setupGlobals: setupGlobals,
|
|
toObject: toObject,
|
|
toProperty: toProperty,
|
|
typeof: typeOf
|
|
};
|
|
})(typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : this);
|
|
(function() {
|
|
'use strict';
|
|
var path;
|
|
function relativeRequire(callerPath, requiredPath) {
|
|
path = path || typeof require !== 'undefined' && require('path');
|
|
function isDirectory(path) {
|
|
return path.slice(-1) === '/';
|
|
}
|
|
function isAbsolute(path) {
|
|
return path[0] === '/';
|
|
}
|
|
function isRelative(path) {
|
|
return path[0] === '.';
|
|
}
|
|
if (isDirectory(requiredPath) || isAbsolute(requiredPath))
|
|
return;
|
|
return isRelative(requiredPath) ? require(path.resolve(path.dirname(callerPath), requiredPath)) : require(requiredPath);
|
|
}
|
|
$traceurRuntime.require = relativeRequire;
|
|
})();
|
|
(function() {
|
|
'use strict';
|
|
function spread() {
|
|
var rv = [],
|
|
j = 0,
|
|
iterResult;
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
var valueToSpread = $traceurRuntime.checkObjectCoercible(arguments[i]);
|
|
if (typeof valueToSpread[$traceurRuntime.toProperty(Symbol.iterator)] !== 'function') {
|
|
throw new TypeError('Cannot spread non-iterable object.');
|
|
}
|
|
var iter = valueToSpread[$traceurRuntime.toProperty(Symbol.iterator)]();
|
|
while (!(iterResult = iter.next()).done) {
|
|
rv[j++] = iterResult.value;
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
$traceurRuntime.spread = spread;
|
|
})();
|
|
(function() {
|
|
'use strict';
|
|
var $Object = Object;
|
|
var $TypeError = TypeError;
|
|
var $create = $Object.create;
|
|
var $defineProperties = $traceurRuntime.defineProperties;
|
|
var $defineProperty = $traceurRuntime.defineProperty;
|
|
var $getOwnPropertyDescriptor = $traceurRuntime.getOwnPropertyDescriptor;
|
|
var $getOwnPropertyNames = $traceurRuntime.getOwnPropertyNames;
|
|
var $getPrototypeOf = Object.getPrototypeOf;
|
|
var $__0 = Object,
|
|
getOwnPropertyNames = $__0.getOwnPropertyNames,
|
|
getOwnPropertySymbols = $__0.getOwnPropertySymbols;
|
|
function superDescriptor(homeObject, name) {
|
|
var proto = $getPrototypeOf(homeObject);
|
|
do {
|
|
var result = $getOwnPropertyDescriptor(proto, name);
|
|
if (result)
|
|
return result;
|
|
proto = $getPrototypeOf(proto);
|
|
} while (proto);
|
|
return undefined;
|
|
}
|
|
function superConstructor(ctor) {
|
|
return ctor.__proto__;
|
|
}
|
|
function superCall(self, homeObject, name, args) {
|
|
return superGet(self, homeObject, name).apply(self, args);
|
|
}
|
|
function superGet(self, homeObject, name) {
|
|
var descriptor = superDescriptor(homeObject, name);
|
|
if (descriptor) {
|
|
if (!descriptor.get)
|
|
return descriptor.value;
|
|
return descriptor.get.call(self);
|
|
}
|
|
return undefined;
|
|
}
|
|
function superSet(self, homeObject, name, value) {
|
|
var descriptor = superDescriptor(homeObject, name);
|
|
if (descriptor && descriptor.set) {
|
|
descriptor.set.call(self, value);
|
|
return value;
|
|
}
|
|
throw $TypeError(("super has no setter '" + name + "'."));
|
|
}
|
|
function getDescriptors(object) {
|
|
var descriptors = {};
|
|
var names = getOwnPropertyNames(object);
|
|
for (var i = 0; i < names.length; i++) {
|
|
var name = names[i];
|
|
descriptors[name] = $getOwnPropertyDescriptor(object, name);
|
|
}
|
|
var symbols = getOwnPropertySymbols(object);
|
|
for (var i = 0; i < symbols.length; i++) {
|
|
var symbol = symbols[i];
|
|
descriptors[$traceurRuntime.toProperty(symbol)] = $getOwnPropertyDescriptor(object, $traceurRuntime.toProperty(symbol));
|
|
}
|
|
return descriptors;
|
|
}
|
|
function createClass(ctor, object, staticObject, superClass) {
|
|
$defineProperty(object, 'constructor', {
|
|
value: ctor,
|
|
configurable: true,
|
|
enumerable: false,
|
|
writable: true
|
|
});
|
|
if (arguments.length > 3) {
|
|
if (typeof superClass === 'function')
|
|
ctor.__proto__ = superClass;
|
|
ctor.prototype = $create(getProtoParent(superClass), getDescriptors(object));
|
|
} else {
|
|
ctor.prototype = object;
|
|
}
|
|
$defineProperty(ctor, 'prototype', {
|
|
configurable: false,
|
|
writable: false
|
|
});
|
|
return $defineProperties(ctor, getDescriptors(staticObject));
|
|
}
|
|
function getProtoParent(superClass) {
|
|
if (typeof superClass === 'function') {
|
|
var prototype = superClass.prototype;
|
|
if ($Object(prototype) === prototype || prototype === null)
|
|
return superClass.prototype;
|
|
throw new $TypeError('super prototype must be an Object or null');
|
|
}
|
|
if (superClass === null)
|
|
return null;
|
|
throw new $TypeError(("Super expression must either be null or a function, not " + typeof superClass + "."));
|
|
}
|
|
function defaultSuperCall(self, homeObject, args) {
|
|
if ($getPrototypeOf(homeObject) !== null)
|
|
superCall(self, homeObject, 'constructor', args);
|
|
}
|
|
$traceurRuntime.createClass = createClass;
|
|
$traceurRuntime.defaultSuperCall = defaultSuperCall;
|
|
$traceurRuntime.superCall = superCall;
|
|
$traceurRuntime.superConstructor = superConstructor;
|
|
$traceurRuntime.superGet = superGet;
|
|
$traceurRuntime.superSet = superSet;
|
|
})();
|
|
(function() {
|
|
'use strict';
|
|
if (typeof $traceurRuntime !== 'object') {
|
|
throw new Error('traceur runtime not found.');
|
|
}
|
|
var createPrivateName = $traceurRuntime.createPrivateName;
|
|
var $defineProperties = $traceurRuntime.defineProperties;
|
|
var $defineProperty = $traceurRuntime.defineProperty;
|
|
var $create = Object.create;
|
|
var $TypeError = TypeError;
|
|
function nonEnum(value) {
|
|
return {
|
|
configurable: true,
|
|
enumerable: false,
|
|
value: value,
|
|
writable: true
|
|
};
|
|
}
|
|
var ST_NEWBORN = 0;
|
|
var ST_EXECUTING = 1;
|
|
var ST_SUSPENDED = 2;
|
|
var ST_CLOSED = 3;
|
|
var END_STATE = -2;
|
|
var RETHROW_STATE = -3;
|
|
function getInternalError(state) {
|
|
return new Error('Traceur compiler bug: invalid state in state machine: ' + state);
|
|
}
|
|
function GeneratorContext() {
|
|
this.state = 0;
|
|
this.GState = ST_NEWBORN;
|
|
this.storedException = undefined;
|
|
this.finallyFallThrough = undefined;
|
|
this.sent_ = undefined;
|
|
this.returnValue = undefined;
|
|
this.tryStack_ = [];
|
|
}
|
|
GeneratorContext.prototype = {
|
|
pushTry: function(catchState, finallyState) {
|
|
if (finallyState !== null) {
|
|
var finallyFallThrough = null;
|
|
for (var i = this.tryStack_.length - 1; i >= 0; i--) {
|
|
if (this.tryStack_[i].catch !== undefined) {
|
|
finallyFallThrough = this.tryStack_[i].catch;
|
|
break;
|
|
}
|
|
}
|
|
if (finallyFallThrough === null)
|
|
finallyFallThrough = RETHROW_STATE;
|
|
this.tryStack_.push({
|
|
finally: finallyState,
|
|
finallyFallThrough: finallyFallThrough
|
|
});
|
|
}
|
|
if (catchState !== null) {
|
|
this.tryStack_.push({catch: catchState});
|
|
}
|
|
},
|
|
popTry: function() {
|
|
this.tryStack_.pop();
|
|
},
|
|
get sent() {
|
|
this.maybeThrow();
|
|
return this.sent_;
|
|
},
|
|
set sent(v) {
|
|
this.sent_ = v;
|
|
},
|
|
get sentIgnoreThrow() {
|
|
return this.sent_;
|
|
},
|
|
maybeThrow: function() {
|
|
if (this.action === 'throw') {
|
|
this.action = 'next';
|
|
throw this.sent_;
|
|
}
|
|
},
|
|
end: function() {
|
|
switch (this.state) {
|
|
case END_STATE:
|
|
return this;
|
|
case RETHROW_STATE:
|
|
throw this.storedException;
|
|
default:
|
|
throw getInternalError(this.state);
|
|
}
|
|
},
|
|
handleException: function(ex) {
|
|
this.GState = ST_CLOSED;
|
|
this.state = END_STATE;
|
|
throw ex;
|
|
}
|
|
};
|
|
function nextOrThrow(ctx, moveNext, action, x) {
|
|
switch (ctx.GState) {
|
|
case ST_EXECUTING:
|
|
throw new Error(("\"" + action + "\" on executing generator"));
|
|
case ST_CLOSED:
|
|
if (action == 'next') {
|
|
return {
|
|
value: undefined,
|
|
done: true
|
|
};
|
|
}
|
|
throw x;
|
|
case ST_NEWBORN:
|
|
if (action === 'throw') {
|
|
ctx.GState = ST_CLOSED;
|
|
throw x;
|
|
}
|
|
if (x !== undefined)
|
|
throw $TypeError('Sent value to newborn generator');
|
|
case ST_SUSPENDED:
|
|
ctx.GState = ST_EXECUTING;
|
|
ctx.action = action;
|
|
ctx.sent = x;
|
|
var value = moveNext(ctx);
|
|
var done = value === ctx;
|
|
if (done)
|
|
value = ctx.returnValue;
|
|
ctx.GState = done ? ST_CLOSED : ST_SUSPENDED;
|
|
return {
|
|
value: value,
|
|
done: done
|
|
};
|
|
}
|
|
}
|
|
var ctxName = createPrivateName();
|
|
var moveNextName = createPrivateName();
|
|
function GeneratorFunction() {}
|
|
function GeneratorFunctionPrototype() {}
|
|
GeneratorFunction.prototype = GeneratorFunctionPrototype;
|
|
$defineProperty(GeneratorFunctionPrototype, 'constructor', nonEnum(GeneratorFunction));
|
|
GeneratorFunctionPrototype.prototype = {
|
|
constructor: GeneratorFunctionPrototype,
|
|
next: function(v) {
|
|
return nextOrThrow(this[ctxName], this[moveNextName], 'next', v);
|
|
},
|
|
throw: function(v) {
|
|
return nextOrThrow(this[ctxName], this[moveNextName], 'throw', v);
|
|
}
|
|
};
|
|
$defineProperties(GeneratorFunctionPrototype.prototype, {
|
|
constructor: {enumerable: false},
|
|
next: {enumerable: false},
|
|
throw: {enumerable: false}
|
|
});
|
|
Object.defineProperty(GeneratorFunctionPrototype.prototype, Symbol.iterator, nonEnum(function() {
|
|
return this;
|
|
}));
|
|
function createGeneratorInstance(innerFunction, functionObject, self) {
|
|
var moveNext = getMoveNext(innerFunction, self);
|
|
var ctx = new GeneratorContext();
|
|
var object = $create(functionObject.prototype);
|
|
object[ctxName] = ctx;
|
|
object[moveNextName] = moveNext;
|
|
return object;
|
|
}
|
|
function initGeneratorFunction(functionObject) {
|
|
functionObject.prototype = $create(GeneratorFunctionPrototype.prototype);
|
|
functionObject.__proto__ = GeneratorFunctionPrototype;
|
|
return functionObject;
|
|
}
|
|
function AsyncFunctionContext() {
|
|
GeneratorContext.call(this);
|
|
this.err = undefined;
|
|
var ctx = this;
|
|
ctx.result = new Promise(function(resolve, reject) {
|
|
ctx.resolve = resolve;
|
|
ctx.reject = reject;
|
|
});
|
|
}
|
|
AsyncFunctionContext.prototype = $create(GeneratorContext.prototype);
|
|
AsyncFunctionContext.prototype.end = function() {
|
|
switch (this.state) {
|
|
case END_STATE:
|
|
this.resolve(this.returnValue);
|
|
break;
|
|
case RETHROW_STATE:
|
|
this.reject(this.storedException);
|
|
break;
|
|
default:
|
|
this.reject(getInternalError(this.state));
|
|
}
|
|
};
|
|
AsyncFunctionContext.prototype.handleException = function() {
|
|
this.state = RETHROW_STATE;
|
|
};
|
|
function asyncWrap(innerFunction, self) {
|
|
var moveNext = getMoveNext(innerFunction, self);
|
|
var ctx = new AsyncFunctionContext();
|
|
ctx.createCallback = function(newState) {
|
|
return function(value) {
|
|
ctx.state = newState;
|
|
ctx.value = value;
|
|
moveNext(ctx);
|
|
};
|
|
};
|
|
ctx.errback = function(err) {
|
|
handleCatch(ctx, err);
|
|
moveNext(ctx);
|
|
};
|
|
moveNext(ctx);
|
|
return ctx.result;
|
|
}
|
|
function getMoveNext(innerFunction, self) {
|
|
return function(ctx) {
|
|
while (true) {
|
|
try {
|
|
return innerFunction.call(self, ctx);
|
|
} catch (ex) {
|
|
handleCatch(ctx, ex);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function handleCatch(ctx, ex) {
|
|
ctx.storedException = ex;
|
|
var last = ctx.tryStack_[ctx.tryStack_.length - 1];
|
|
if (!last) {
|
|
ctx.handleException(ex);
|
|
return;
|
|
}
|
|
ctx.state = last.catch !== undefined ? last.catch : last.finally;
|
|
if (last.finallyFallThrough !== undefined)
|
|
ctx.finallyFallThrough = last.finallyFallThrough;
|
|
}
|
|
$traceurRuntime.asyncWrap = asyncWrap;
|
|
$traceurRuntime.initGeneratorFunction = initGeneratorFunction;
|
|
$traceurRuntime.createGeneratorInstance = createGeneratorInstance;
|
|
})();
|
|
(function() {
|
|
function buildFromEncodedParts(opt_scheme, opt_userInfo, opt_domain, opt_port, opt_path, opt_queryData, opt_fragment) {
|
|
var out = [];
|
|
if (opt_scheme) {
|
|
out.push(opt_scheme, ':');
|
|
}
|
|
if (opt_domain) {
|
|
out.push('//');
|
|
if (opt_userInfo) {
|
|
out.push(opt_userInfo, '@');
|
|
}
|
|
out.push(opt_domain);
|
|
if (opt_port) {
|
|
out.push(':', opt_port);
|
|
}
|
|
}
|
|
if (opt_path) {
|
|
out.push(opt_path);
|
|
}
|
|
if (opt_queryData) {
|
|
out.push('?', opt_queryData);
|
|
}
|
|
if (opt_fragment) {
|
|
out.push('#', opt_fragment);
|
|
}
|
|
return out.join('');
|
|
}
|
|
;
|
|
var splitRe = new RegExp('^' + '(?:' + '([^:/?#.]+)' + ':)?' + '(?://' + '(?:([^/?#]*)@)?' + '([\\w\\d\\-\\u0100-\\uffff.%]*)' + '(?::([0-9]+))?' + ')?' + '([^?#]+)?' + '(?:\\?([^#]*))?' + '(?:#(.*))?' + '$');
|
|
var ComponentIndex = {
|
|
SCHEME: 1,
|
|
USER_INFO: 2,
|
|
DOMAIN: 3,
|
|
PORT: 4,
|
|
PATH: 5,
|
|
QUERY_DATA: 6,
|
|
FRAGMENT: 7
|
|
};
|
|
function split(uri) {
|
|
return (uri.match(splitRe));
|
|
}
|
|
function removeDotSegments(path) {
|
|
if (path === '/')
|
|
return '/';
|
|
var leadingSlash = path[0] === '/' ? '/' : '';
|
|
var trailingSlash = path.slice(-1) === '/' ? '/' : '';
|
|
var segments = path.split('/');
|
|
var out = [];
|
|
var up = 0;
|
|
for (var pos = 0; pos < segments.length; pos++) {
|
|
var segment = segments[pos];
|
|
switch (segment) {
|
|
case '':
|
|
case '.':
|
|
break;
|
|
case '..':
|
|
if (out.length)
|
|
out.pop();
|
|
else
|
|
up++;
|
|
break;
|
|
default:
|
|
out.push(segment);
|
|
}
|
|
}
|
|
if (!leadingSlash) {
|
|
while (up-- > 0) {
|
|
out.unshift('..');
|
|
}
|
|
if (out.length === 0)
|
|
out.push('.');
|
|
}
|
|
return leadingSlash + out.join('/') + trailingSlash;
|
|
}
|
|
function joinAndCanonicalizePath(parts) {
|
|
var path = parts[ComponentIndex.PATH] || '';
|
|
path = removeDotSegments(path);
|
|
parts[ComponentIndex.PATH] = path;
|
|
return buildFromEncodedParts(parts[ComponentIndex.SCHEME], parts[ComponentIndex.USER_INFO], parts[ComponentIndex.DOMAIN], parts[ComponentIndex.PORT], parts[ComponentIndex.PATH], parts[ComponentIndex.QUERY_DATA], parts[ComponentIndex.FRAGMENT]);
|
|
}
|
|
function canonicalizeUrl(url) {
|
|
var parts = split(url);
|
|
return joinAndCanonicalizePath(parts);
|
|
}
|
|
function resolveUrl(base, url) {
|
|
var parts = split(url);
|
|
var baseParts = split(base);
|
|
if (parts[ComponentIndex.SCHEME]) {
|
|
return joinAndCanonicalizePath(parts);
|
|
} else {
|
|
parts[ComponentIndex.SCHEME] = baseParts[ComponentIndex.SCHEME];
|
|
}
|
|
for (var i = ComponentIndex.SCHEME; i <= ComponentIndex.PORT; i++) {
|
|
if (!parts[i]) {
|
|
parts[i] = baseParts[i];
|
|
}
|
|
}
|
|
if (parts[ComponentIndex.PATH][0] == '/') {
|
|
return joinAndCanonicalizePath(parts);
|
|
}
|
|
var path = baseParts[ComponentIndex.PATH];
|
|
var index = path.lastIndexOf('/');
|
|
path = path.slice(0, index + 1) + parts[ComponentIndex.PATH];
|
|
parts[ComponentIndex.PATH] = path;
|
|
return joinAndCanonicalizePath(parts);
|
|
}
|
|
function isAbsolute(name) {
|
|
if (!name)
|
|
return false;
|
|
if (name[0] === '/')
|
|
return true;
|
|
var parts = split(name);
|
|
if (parts[ComponentIndex.SCHEME])
|
|
return true;
|
|
return false;
|
|
}
|
|
$traceurRuntime.canonicalizeUrl = canonicalizeUrl;
|
|
$traceurRuntime.isAbsolute = isAbsolute;
|
|
$traceurRuntime.removeDotSegments = removeDotSegments;
|
|
$traceurRuntime.resolveUrl = resolveUrl;
|
|
})();
|
|
(function() {
|
|
'use strict';
|
|
var types = {
|
|
any: {name: 'any'},
|
|
boolean: {name: 'boolean'},
|
|
number: {name: 'number'},
|
|
string: {name: 'string'},
|
|
symbol: {name: 'symbol'},
|
|
void: {name: 'void'}
|
|
};
|
|
var GenericType = function GenericType(type, argumentTypes) {
|
|
this.type = type;
|
|
this.argumentTypes = argumentTypes;
|
|
};
|
|
($traceurRuntime.createClass)(GenericType, {}, {});
|
|
var typeRegister = Object.create(null);
|
|
function genericType(type) {
|
|
for (var argumentTypes = [],
|
|
$__1 = 1; $__1 < arguments.length; $__1++)
|
|
argumentTypes[$__1 - 1] = arguments[$__1];
|
|
var typeMap = typeRegister;
|
|
var key = $traceurRuntime.getOwnHashObject(type).hash;
|
|
if (!typeMap[key]) {
|
|
typeMap[key] = Object.create(null);
|
|
}
|
|
typeMap = typeMap[key];
|
|
for (var i = 0; i < argumentTypes.length - 1; i++) {
|
|
key = $traceurRuntime.getOwnHashObject(argumentTypes[i]).hash;
|
|
if (!typeMap[key]) {
|
|
typeMap[key] = Object.create(null);
|
|
}
|
|
typeMap = typeMap[key];
|
|
}
|
|
var tail = argumentTypes[argumentTypes.length - 1];
|
|
key = $traceurRuntime.getOwnHashObject(tail).hash;
|
|
if (!typeMap[key]) {
|
|
typeMap[key] = new GenericType(type, argumentTypes);
|
|
}
|
|
return typeMap[key];
|
|
}
|
|
$traceurRuntime.GenericType = GenericType;
|
|
$traceurRuntime.genericType = genericType;
|
|
$traceurRuntime.type = types;
|
|
})();
|
|
(function(global) {
|
|
'use strict';
|
|
var $__2 = $traceurRuntime,
|
|
canonicalizeUrl = $__2.canonicalizeUrl,
|
|
resolveUrl = $__2.resolveUrl,
|
|
isAbsolute = $__2.isAbsolute;
|
|
var moduleInstantiators = Object.create(null);
|
|
var baseURL;
|
|
if (global.location && global.location.href)
|
|
baseURL = resolveUrl(global.location.href, './');
|
|
else
|
|
baseURL = '';
|
|
var UncoatedModuleEntry = function UncoatedModuleEntry(url, uncoatedModule) {
|
|
this.url = url;
|
|
this.value_ = uncoatedModule;
|
|
};
|
|
($traceurRuntime.createClass)(UncoatedModuleEntry, {}, {});
|
|
var ModuleEvaluationError = function ModuleEvaluationError(erroneousModuleName, cause) {
|
|
this.message = this.constructor.name + ': ' + this.stripCause(cause) + ' in ' + erroneousModuleName;
|
|
if (!(cause instanceof $ModuleEvaluationError) && cause.stack)
|
|
this.stack = this.stripStack(cause.stack);
|
|
else
|
|
this.stack = '';
|
|
};
|
|
var $ModuleEvaluationError = ModuleEvaluationError;
|
|
($traceurRuntime.createClass)(ModuleEvaluationError, {
|
|
stripError: function(message) {
|
|
return message.replace(/.*Error:/, this.constructor.name + ':');
|
|
},
|
|
stripCause: function(cause) {
|
|
if (!cause)
|
|
return '';
|
|
if (!cause.message)
|
|
return cause + '';
|
|
return this.stripError(cause.message);
|
|
},
|
|
loadedBy: function(moduleName) {
|
|
this.stack += '\n loaded by ' + moduleName;
|
|
},
|
|
stripStack: function(causeStack) {
|
|
var stack = [];
|
|
causeStack.split('\n').some((function(frame) {
|
|
if (/UncoatedModuleInstantiator/.test(frame))
|
|
return true;
|
|
stack.push(frame);
|
|
}));
|
|
stack[0] = this.stripError(stack[0]);
|
|
return stack.join('\n');
|
|
}
|
|
}, {}, Error);
|
|
function beforeLines(lines, number) {
|
|
var result = [];
|
|
var first = number - 3;
|
|
if (first < 0)
|
|
first = 0;
|
|
for (var i = first; i < number; i++) {
|
|
result.push(lines[i]);
|
|
}
|
|
return result;
|
|
}
|
|
function afterLines(lines, number) {
|
|
var last = number + 1;
|
|
if (last > lines.length - 1)
|
|
last = lines.length - 1;
|
|
var result = [];
|
|
for (var i = number; i <= last; i++) {
|
|
result.push(lines[i]);
|
|
}
|
|
return result;
|
|
}
|
|
function columnSpacing(columns) {
|
|
var result = '';
|
|
for (var i = 0; i < columns - 1; i++) {
|
|
result += '-';
|
|
}
|
|
return result;
|
|
}
|
|
var UncoatedModuleInstantiator = function UncoatedModuleInstantiator(url, func) {
|
|
$traceurRuntime.superConstructor($UncoatedModuleInstantiator).call(this, url, null);
|
|
this.func = func;
|
|
};
|
|
var $UncoatedModuleInstantiator = UncoatedModuleInstantiator;
|
|
($traceurRuntime.createClass)(UncoatedModuleInstantiator, {getUncoatedModule: function() {
|
|
if (this.value_)
|
|
return this.value_;
|
|
try {
|
|
var relativeRequire;
|
|
if (typeof $traceurRuntime !== undefined) {
|
|
relativeRequire = $traceurRuntime.require.bind(null, this.url);
|
|
}
|
|
return this.value_ = this.func.call(global, relativeRequire);
|
|
} catch (ex) {
|
|
if (ex instanceof ModuleEvaluationError) {
|
|
ex.loadedBy(this.url);
|
|
throw ex;
|
|
}
|
|
if (ex.stack) {
|
|
var lines = this.func.toString().split('\n');
|
|
var evaled = [];
|
|
ex.stack.split('\n').some(function(frame) {
|
|
if (frame.indexOf('UncoatedModuleInstantiator.getUncoatedModule') > 0)
|
|
return true;
|
|
var m = /(at\s[^\s]*\s).*>:(\d*):(\d*)\)/.exec(frame);
|
|
if (m) {
|
|
var line = parseInt(m[2], 10);
|
|
evaled = evaled.concat(beforeLines(lines, line));
|
|
evaled.push(columnSpacing(m[3]) + '^');
|
|
evaled = evaled.concat(afterLines(lines, line));
|
|
evaled.push('= = = = = = = = =');
|
|
} else {
|
|
evaled.push(frame);
|
|
}
|
|
});
|
|
ex.stack = evaled.join('\n');
|
|
}
|
|
throw new ModuleEvaluationError(this.url, ex);
|
|
}
|
|
}}, {}, UncoatedModuleEntry);
|
|
function getUncoatedModuleInstantiator(name) {
|
|
if (!name)
|
|
return;
|
|
var url = ModuleStore.normalize(name);
|
|
return moduleInstantiators[url];
|
|
}
|
|
;
|
|
var moduleInstances = Object.create(null);
|
|
var liveModuleSentinel = {};
|
|
function Module(uncoatedModule) {
|
|
var isLive = arguments[1];
|
|
var coatedModule = Object.create(null);
|
|
Object.getOwnPropertyNames(uncoatedModule).forEach((function(name) {
|
|
var getter,
|
|
value;
|
|
if (isLive === liveModuleSentinel) {
|
|
var descr = Object.getOwnPropertyDescriptor(uncoatedModule, name);
|
|
if (descr.get)
|
|
getter = descr.get;
|
|
}
|
|
if (!getter) {
|
|
value = uncoatedModule[name];
|
|
getter = function() {
|
|
return value;
|
|
};
|
|
}
|
|
Object.defineProperty(coatedModule, name, {
|
|
get: getter,
|
|
enumerable: true
|
|
});
|
|
}));
|
|
Object.preventExtensions(coatedModule);
|
|
return coatedModule;
|
|
}
|
|
var ModuleStore = {
|
|
normalize: function(name, refererName, refererAddress) {
|
|
if (typeof name !== 'string')
|
|
throw new TypeError('module name must be a string, not ' + typeof name);
|
|
if (isAbsolute(name))
|
|
return canonicalizeUrl(name);
|
|
if (/[^\.]\/\.\.\//.test(name)) {
|
|
throw new Error('module name embeds /../: ' + name);
|
|
}
|
|
if (name[0] === '.' && refererName)
|
|
return resolveUrl(refererName, name);
|
|
return canonicalizeUrl(name);
|
|
},
|
|
get: function(normalizedName) {
|
|
var m = getUncoatedModuleInstantiator(normalizedName);
|
|
if (!m)
|
|
return undefined;
|
|
var moduleInstance = moduleInstances[m.url];
|
|
if (moduleInstance)
|
|
return moduleInstance;
|
|
moduleInstance = Module(m.getUncoatedModule(), liveModuleSentinel);
|
|
return moduleInstances[m.url] = moduleInstance;
|
|
},
|
|
set: function(normalizedName, module) {
|
|
normalizedName = String(normalizedName);
|
|
moduleInstantiators[normalizedName] = new UncoatedModuleInstantiator(normalizedName, (function() {
|
|
return module;
|
|
}));
|
|
moduleInstances[normalizedName] = module;
|
|
},
|
|
get baseURL() {
|
|
return baseURL;
|
|
},
|
|
set baseURL(v) {
|
|
baseURL = String(v);
|
|
},
|
|
registerModule: function(name, deps, func) {
|
|
var normalizedName = ModuleStore.normalize(name);
|
|
if (moduleInstantiators[normalizedName])
|
|
throw new Error('duplicate module named ' + normalizedName);
|
|
moduleInstantiators[normalizedName] = new UncoatedModuleInstantiator(normalizedName, func);
|
|
},
|
|
bundleStore: Object.create(null),
|
|
register: function(name, deps, func) {
|
|
if (!deps || !deps.length && !func.length) {
|
|
this.registerModule(name, deps, func);
|
|
} else {
|
|
this.bundleStore[name] = {
|
|
deps: deps,
|
|
execute: function() {
|
|
var $__0 = arguments;
|
|
var depMap = {};
|
|
deps.forEach((function(dep, index) {
|
|
return depMap[dep] = $__0[index];
|
|
}));
|
|
var registryEntry = func.call(this, depMap);
|
|
registryEntry.execute.call(this);
|
|
return registryEntry.exports;
|
|
}
|
|
};
|
|
}
|
|
},
|
|
getAnonymousModule: function(func) {
|
|
return new Module(func.call(global), liveModuleSentinel);
|
|
},
|
|
getForTesting: function(name) {
|
|
var $__0 = this;
|
|
if (!this.testingPrefix_) {
|
|
Object.keys(moduleInstances).some((function(key) {
|
|
var m = /(traceur@[^\/]*\/)/.exec(key);
|
|
if (m) {
|
|
$__0.testingPrefix_ = m[1];
|
|
return true;
|
|
}
|
|
}));
|
|
}
|
|
return this.get(this.testingPrefix_ + name);
|
|
}
|
|
};
|
|
var moduleStoreModule = new Module({ModuleStore: ModuleStore});
|
|
ModuleStore.set('@traceur/src/runtime/ModuleStore', moduleStoreModule);
|
|
ModuleStore.set('@traceur/src/runtime/ModuleStore.js', moduleStoreModule);
|
|
var setupGlobals = $traceurRuntime.setupGlobals;
|
|
$traceurRuntime.setupGlobals = function(global) {
|
|
setupGlobals(global);
|
|
};
|
|
$traceurRuntime.ModuleStore = ModuleStore;
|
|
global.System = {
|
|
register: ModuleStore.register.bind(ModuleStore),
|
|
registerModule: ModuleStore.registerModule.bind(ModuleStore),
|
|
get: ModuleStore.get,
|
|
set: ModuleStore.set,
|
|
normalize: ModuleStore.normalize
|
|
};
|
|
$traceurRuntime.getModuleImpl = function(name) {
|
|
var instantiator = getUncoatedModuleInstantiator(name);
|
|
return instantiator && instantiator.getUncoatedModule();
|
|
};
|
|
})(typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : this);
|
|
System.registerModule("traceur-runtime@0.0.79/src/runtime/polyfills/utils.js", [], function() {
|
|
"use strict";
|
|
var __moduleName = "traceur-runtime@0.0.79/src/runtime/polyfills/utils.js";
|
|
var $ceil = Math.ceil;
|
|
var $floor = Math.floor;
|
|
var $isFinite = isFinite;
|
|
var $isNaN = isNaN;
|
|
var $pow = Math.pow;
|
|
var $min = Math.min;
|
|
var toObject = $traceurRuntime.toObject;
|
|
function toUint32(x) {
|
|
return x >>> 0;
|
|
}
|
|
function isObject(x) {
|
|
return x && (typeof x === 'object' || typeof x === 'function');
|
|
}
|
|
function isCallable(x) {
|
|
return typeof x === 'function';
|
|
}
|
|
function isNumber(x) {
|
|
return typeof x === 'number';
|
|
}
|
|
function toInteger(x) {
|
|
x = +x;
|
|
if ($isNaN(x))
|
|
return 0;
|
|
if (x === 0 || !$isFinite(x))
|
|
return x;
|
|
return x > 0 ? $floor(x) : $ceil(x);
|
|
}
|
|
var MAX_SAFE_LENGTH = $pow(2, 53) - 1;
|
|
function toLength(x) {
|
|
var len = toInteger(x);
|
|
return len < 0 ? 0 : $min(len, MAX_SAFE_LENGTH);
|
|
}
|
|
function checkIterable(x) {
|
|
return !isObject(x) ? undefined : x[Symbol.iterator];
|
|
}
|
|
function isConstructor(x) {
|
|
return isCallable(x);
|
|
}
|
|
function createIteratorResultObject(value, done) {
|
|
return {
|
|
value: value,
|
|
done: done
|
|
};
|
|
}
|
|
function maybeDefine(object, name, descr) {
|
|
if (!(name in object)) {
|
|
Object.defineProperty(object, name, descr);
|
|
}
|
|
}
|
|
function maybeDefineMethod(object, name, value) {
|
|
maybeDefine(object, name, {
|
|
value: value,
|
|
configurable: true,
|
|
enumerable: false,
|
|
writable: true
|
|
});
|
|
}
|
|
function maybeDefineConst(object, name, value) {
|
|
maybeDefine(object, name, {
|
|
value: value,
|
|
configurable: false,
|
|
enumerable: false,
|
|
writable: false
|
|
});
|
|
}
|
|
function maybeAddFunctions(object, functions) {
|
|
for (var i = 0; i < functions.length; i += 2) {
|
|
var name = functions[i];
|
|
var value = functions[i + 1];
|
|
maybeDefineMethod(object, name, value);
|
|
}
|
|
}
|
|
function maybeAddConsts(object, consts) {
|
|
for (var i = 0; i < consts.length; i += 2) {
|
|
var name = consts[i];
|
|
var value = consts[i + 1];
|
|
maybeDefineConst(object, name, value);
|
|
}
|
|
}
|
|
function maybeAddIterator(object, func, Symbol) {
|
|
if (!Symbol || !Symbol.iterator || object[Symbol.iterator])
|
|
return;
|
|
if (object['@@iterator'])
|
|
func = object['@@iterator'];
|
|
Object.defineProperty(object, Symbol.iterator, {
|
|
value: func,
|
|
configurable: true,
|
|
enumerable: false,
|
|
writable: true
|
|
});
|
|
}
|
|
var polyfills = [];
|
|
function registerPolyfill(func) {
|
|
polyfills.push(func);
|
|
}
|
|
function polyfillAll(global) {
|
|
polyfills.forEach((function(f) {
|
|
return f(global);
|
|
}));
|
|
}
|
|
return {
|
|
get toObject() {
|
|
return toObject;
|
|
},
|
|
get toUint32() {
|
|
return toUint32;
|
|
},
|
|
get isObject() {
|
|
return isObject;
|
|
},
|
|
get isCallable() {
|
|
return isCallable;
|
|
},
|
|
get isNumber() {
|
|
return isNumber;
|
|
},
|
|
get toInteger() {
|
|
return toInteger;
|
|
},
|
|
get toLength() {
|
|
return toLength;
|
|
},
|
|
get checkIterable() {
|
|
return checkIterable;
|
|
},
|
|
get isConstructor() {
|
|
return isConstructor;
|
|
},
|
|
get createIteratorResultObject() {
|
|
return createIteratorResultObject;
|
|
},
|
|
get maybeDefine() {
|
|
return maybeDefine;
|
|
},
|
|
get maybeDefineMethod() {
|
|
return maybeDefineMethod;
|
|
},
|
|
get maybeDefineConst() {
|
|
return maybeDefineConst;
|
|
},
|
|
get maybeAddFunctions() {
|
|
return maybeAddFunctions;
|
|
},
|
|
get maybeAddConsts() {
|
|
return maybeAddConsts;
|
|
},
|
|
get maybeAddIterator() {
|
|
return maybeAddIterator;
|
|
},
|
|
get registerPolyfill() {
|
|
return registerPolyfill;
|
|
},
|
|
get polyfillAll() {
|
|
return polyfillAll;
|
|
}
|
|
};
|
|
});
|
|
System.registerModule("traceur-runtime@0.0.79/src/runtime/polyfills/Map.js", [], function() {
|
|
"use strict";
|
|
var __moduleName = "traceur-runtime@0.0.79/src/runtime/polyfills/Map.js";
|
|
var $__0 = System.get("traceur-runtime@0.0.79/src/runtime/polyfills/utils.js"),
|
|
isObject = $__0.isObject,
|
|
maybeAddIterator = $__0.maybeAddIterator,
|
|
registerPolyfill = $__0.registerPolyfill;
|
|
var getOwnHashObject = $traceurRuntime.getOwnHashObject;
|
|
var $hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
var deletedSentinel = {};
|
|
function lookupIndex(map, key) {
|
|
if (isObject(key)) {
|
|
var hashObject = getOwnHashObject(key);
|
|
return hashObject && map.objectIndex_[hashObject.hash];
|
|
}
|
|
if (typeof key === 'string')
|
|
return map.stringIndex_[key];
|
|
return map.primitiveIndex_[key];
|
|
}
|
|
function initMap(map) {
|
|
map.entries_ = [];
|
|
map.objectIndex_ = Object.create(null);
|
|
map.stringIndex_ = Object.create(null);
|
|
map.primitiveIndex_ = Object.create(null);
|
|
map.deletedCount_ = 0;
|
|
}
|
|
var Map = function Map() {
|
|
var iterable = arguments[0];
|
|
if (!isObject(this))
|
|
throw new TypeError('Map called on incompatible type');
|
|
if ($hasOwnProperty.call(this, 'entries_')) {
|
|
throw new TypeError('Map can not be reentrantly initialised');
|
|
}
|
|
initMap(this);
|
|
if (iterable !== null && iterable !== undefined) {
|
|
for (var $__2 = iterable[$traceurRuntime.toProperty(Symbol.iterator)](),
|
|
$__3; !($__3 = $__2.next()).done; ) {
|
|
var $__4 = $__3.value,
|
|
key = $__4[0],
|
|
value = $__4[1];
|
|
{
|
|
this.set(key, value);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
($traceurRuntime.createClass)(Map, {
|
|
get size() {
|
|
return this.entries_.length / 2 - this.deletedCount_;
|
|
},
|
|
get: function(key) {
|
|
var index = lookupIndex(this, key);
|
|
if (index !== undefined)
|
|
return this.entries_[index + 1];
|
|
},
|
|
set: function(key, value) {
|
|
var objectMode = isObject(key);
|
|
var stringMode = typeof key === 'string';
|
|
var index = lookupIndex(this, key);
|
|
if (index !== undefined) {
|
|
this.entries_[index + 1] = value;
|
|
} else {
|
|
index = this.entries_.length;
|
|
this.entries_[index] = key;
|
|
this.entries_[index + 1] = value;
|
|
if (objectMode) {
|
|
var hashObject = getOwnHashObject(key);
|
|
var hash = hashObject.hash;
|
|
this.objectIndex_[hash] = index;
|
|
} else if (stringMode) {
|
|
this.stringIndex_[key] = index;
|
|
} else {
|
|
this.primitiveIndex_[key] = index;
|
|
}
|
|
}
|
|
return this;
|
|
},
|
|
has: function(key) {
|
|
return lookupIndex(this, key) !== undefined;
|
|
},
|
|
delete: function(key) {
|
|
var objectMode = isObject(key);
|
|
var stringMode = typeof key === 'string';
|
|
var index;
|
|
var hash;
|
|
if (objectMode) {
|
|
var hashObject = getOwnHashObject(key);
|
|
if (hashObject) {
|
|
index = this.objectIndex_[hash = hashObject.hash];
|
|
delete this.objectIndex_[hash];
|
|
}
|
|
} else if (stringMode) {
|
|
index = this.stringIndex_[key];
|
|
delete this.stringIndex_[key];
|
|
} else {
|
|
index = this.primitiveIndex_[key];
|
|
delete this.primitiveIndex_[key];
|
|
}
|
|
if (index !== undefined) {
|
|
this.entries_[index] = deletedSentinel;
|
|
this.entries_[index + 1] = undefined;
|
|
this.deletedCount_++;
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
clear: function() {
|
|
initMap(this);
|
|
},
|
|
forEach: function(callbackFn) {
|
|
var thisArg = arguments[1];
|
|
for (var i = 0; i < this.entries_.length; i += 2) {
|
|
var key = this.entries_[i];
|
|
var value = this.entries_[i + 1];
|
|
if (key === deletedSentinel)
|
|
continue;
|
|
callbackFn.call(thisArg, value, key, this);
|
|
}
|
|
},
|
|
entries: $traceurRuntime.initGeneratorFunction(function $__5() {
|
|
var i,
|
|
key,
|
|
value;
|
|
return $traceurRuntime.createGeneratorInstance(function($ctx) {
|
|
while (true)
|
|
switch ($ctx.state) {
|
|
case 0:
|
|
i = 0;
|
|
$ctx.state = 12;
|
|
break;
|
|
case 12:
|
|
$ctx.state = (i < this.entries_.length) ? 8 : -2;
|
|
break;
|
|
case 4:
|
|
i += 2;
|
|
$ctx.state = 12;
|
|
break;
|
|
case 8:
|
|
key = this.entries_[i];
|
|
value = this.entries_[i + 1];
|
|
$ctx.state = 9;
|
|
break;
|
|
case 9:
|
|
$ctx.state = (key === deletedSentinel) ? 4 : 6;
|
|
break;
|
|
case 6:
|
|
$ctx.state = 2;
|
|
return [key, value];
|
|
case 2:
|
|
$ctx.maybeThrow();
|
|
$ctx.state = 4;
|
|
break;
|
|
default:
|
|
return $ctx.end();
|
|
}
|
|
}, $__5, this);
|
|
}),
|
|
keys: $traceurRuntime.initGeneratorFunction(function $__6() {
|
|
var i,
|
|
key,
|
|
value;
|
|
return $traceurRuntime.createGeneratorInstance(function($ctx) {
|
|
while (true)
|
|
switch ($ctx.state) {
|
|
case 0:
|
|
i = 0;
|
|
$ctx.state = 12;
|
|
break;
|
|
case 12:
|
|
$ctx.state = (i < this.entries_.length) ? 8 : -2;
|
|
break;
|
|
case 4:
|
|
i += 2;
|
|
$ctx.state = 12;
|
|
break;
|
|
case 8:
|
|
key = this.entries_[i];
|
|
value = this.entries_[i + 1];
|
|
$ctx.state = 9;
|
|
break;
|
|
case 9:
|
|
$ctx.state = (key === deletedSentinel) ? 4 : 6;
|
|
break;
|
|
case 6:
|
|
$ctx.state = 2;
|
|
return key;
|
|
case 2:
|
|
$ctx.maybeThrow();
|
|
$ctx.state = 4;
|
|
break;
|
|
default:
|
|
return $ctx.end();
|
|
}
|
|
}, $__6, this);
|
|
}),
|
|
values: $traceurRuntime.initGeneratorFunction(function $__7() {
|
|
var i,
|
|
key,
|
|
value;
|
|
return $traceurRuntime.createGeneratorInstance(function($ctx) {
|
|
while (true)
|
|
switch ($ctx.state) {
|
|
case 0:
|
|
i = 0;
|
|
$ctx.state = 12;
|
|
break;
|
|
case 12:
|
|
$ctx.state = (i < this.entries_.length) ? 8 : -2;
|
|
break;
|
|
case 4:
|
|
i += 2;
|
|
$ctx.state = 12;
|
|
break;
|
|
case 8:
|
|
key = this.entries_[i];
|
|
value = this.entries_[i + 1];
|
|
$ctx.state = 9;
|
|
break;
|
|
case 9:
|
|
$ctx.state = (key === deletedSentinel) ? 4 : 6;
|
|
break;
|
|
case 6:
|
|
$ctx.state = 2;
|
|
return value;
|
|
case 2:
|
|
$ctx.maybeThrow();
|
|
$ctx.state = 4;
|
|
break;
|
|
default:
|
|
return $ctx.end();
|
|
}
|
|
}, $__7, this);
|
|
})
|
|
}, {});
|
|
Object.defineProperty(Map.prototype, Symbol.iterator, {
|
|
configurable: true,
|
|
writable: true,
|
|
value: Map.prototype.entries
|
|
});
|
|
function polyfillMap(global) {
|
|
var $__4 = global,
|
|
Object = $__4.Object,
|
|
Symbol = $__4.Symbol;
|
|
if (!global.Map)
|
|
global.Map = Map;
|
|
var mapPrototype = global.Map.prototype;
|
|
if (mapPrototype.entries === undefined)
|
|
global.Map = Map;
|
|
if (mapPrototype.entries) {
|
|
maybeAddIterator(mapPrototype, mapPrototype.entries, Symbol);
|
|
maybeAddIterator(Object.getPrototypeOf(new global.Map().entries()), function() {
|
|
return this;
|
|
}, Symbol);
|
|
}
|
|
}
|
|
registerPolyfill(polyfillMap);
|
|
return {
|
|
get Map() {
|
|
return Map;
|
|
},
|
|
get polyfillMap() {
|
|
return polyfillMap;
|
|
}
|
|
};
|
|
});
|
|
System.get("traceur-runtime@0.0.79/src/runtime/polyfills/Map.js" + '');
|
|
System.registerModule("traceur-runtime@0.0.79/src/runtime/polyfills/Set.js", [], function() {
|
|
"use strict";
|
|
var __moduleName = "traceur-runtime@0.0.79/src/runtime/polyfills/Set.js";
|
|
var $__0 = System.get("traceur-runtime@0.0.79/src/runtime/polyfills/utils.js"),
|
|
isObject = $__0.isObject,
|
|
maybeAddIterator = $__0.maybeAddIterator,
|
|
registerPolyfill = $__0.registerPolyfill;
|
|
var Map = System.get("traceur-runtime@0.0.79/src/runtime/polyfills/Map.js").Map;
|
|
var getOwnHashObject = $traceurRuntime.getOwnHashObject;
|
|
var $hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
function initSet(set) {
|
|
set.map_ = new Map();
|
|
}
|
|
var Set = function Set() {
|
|
var iterable = arguments[0];
|
|
if (!isObject(this))
|
|
throw new TypeError('Set called on incompatible type');
|
|
if ($hasOwnProperty.call(this, 'map_')) {
|
|
throw new TypeError('Set can not be reentrantly initialised');
|
|
}
|
|
initSet(this);
|
|
if (iterable !== null && iterable !== undefined) {
|
|
for (var $__4 = iterable[$traceurRuntime.toProperty(Symbol.iterator)](),
|
|
$__5; !($__5 = $__4.next()).done; ) {
|
|
var item = $__5.value;
|
|
{
|
|
this.add(item);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
($traceurRuntime.createClass)(Set, {
|
|
get size() {
|
|
return this.map_.size;
|
|
},
|
|
has: function(key) {
|
|
return this.map_.has(key);
|
|
},
|
|
add: function(key) {
|
|
this.map_.set(key, key);
|
|
return this;
|
|
},
|
|
delete: function(key) {
|
|
return this.map_.delete(key);
|
|
},
|
|
clear: function() {
|
|
return this.map_.clear();
|
|
},
|
|
forEach: function(callbackFn) {
|
|
var thisArg = arguments[1];
|
|
var $__2 = this;
|
|
return this.map_.forEach((function(value, key) {
|
|
callbackFn.call(thisArg, key, key, $__2);
|
|
}));
|
|
},
|
|
values: $traceurRuntime.initGeneratorFunction(function $__7() {
|
|
var $__8,
|
|
$__9;
|
|
return $traceurRuntime.createGeneratorInstance(function($ctx) {
|
|
while (true)
|
|
switch ($ctx.state) {
|
|
case 0:
|
|
$__8 = this.map_.keys()[Symbol.iterator]();
|
|
$ctx.sent = void 0;
|
|
$ctx.action = 'next';
|
|
$ctx.state = 12;
|
|
break;
|
|
case 12:
|
|
$__9 = $__8[$ctx.action]($ctx.sentIgnoreThrow);
|
|
$ctx.state = 9;
|
|
break;
|
|
case 9:
|
|
$ctx.state = ($__9.done) ? 3 : 2;
|
|
break;
|
|
case 3:
|
|
$ctx.sent = $__9.value;
|
|
$ctx.state = -2;
|
|
break;
|
|
case 2:
|
|
$ctx.state = 12;
|
|
return $__9.value;
|
|
default:
|
|
return $ctx.end();
|
|
}
|
|
}, $__7, this);
|
|
}),
|
|
entries: $traceurRuntime.initGeneratorFunction(function $__10() {
|
|
var $__11,
|
|
$__12;
|
|
return $traceurRuntime.createGeneratorInstance(function($ctx) {
|
|
while (true)
|
|
switch ($ctx.state) {
|
|
case 0:
|
|
$__11 = this.map_.entries()[Symbol.iterator]();
|
|
$ctx.sent = void 0;
|
|
$ctx.action = 'next';
|
|
$ctx.state = 12;
|
|
break;
|
|
case 12:
|
|
$__12 = $__11[$ctx.action]($ctx.sentIgnoreThrow);
|
|
$ctx.state = 9;
|
|
break;
|
|
case 9:
|
|
$ctx.state = ($__12.done) ? 3 : 2;
|
|
break;
|
|
case 3:
|
|
$ctx.sent = $__12.value;
|
|
$ctx.state = -2;
|
|
break;
|
|
case 2:
|
|
$ctx.state = 12;
|
|
return $__12.value;
|
|
default:
|
|
return $ctx.end();
|
|
}
|
|
}, $__10, this);
|
|
})
|
|
}, {});
|
|
Object.defineProperty(Set.prototype, Symbol.iterator, {
|
|
configurable: true,
|
|
writable: true,
|
|
value: Set.prototype.values
|
|
});
|
|
Object.defineProperty(Set.prototype, 'keys', {
|
|
configurable: true,
|
|
writable: true,
|
|
value: Set.prototype.values
|
|
});
|
|
function polyfillSet(global) {
|
|
var $__6 = global,
|
|
Object = $__6.Object,
|
|
Symbol = $__6.Symbol;
|
|
if (!global.Set)
|
|
global.Set = Set;
|
|
var setPrototype = global.Set.prototype;
|
|
if (setPrototype.values) {
|
|
maybeAddIterator(setPrototype, setPrototype.values, Symbol);
|
|
maybeAddIterator(Object.getPrototypeOf(new global.Set().values()), function() {
|
|
return this;
|
|
}, Symbol);
|
|
}
|
|
}
|
|
registerPolyfill(polyfillSet);
|
|
return {
|
|
get Set() {
|
|
return Set;
|
|
},
|
|
get polyfillSet() {
|
|
return polyfillSet;
|
|
}
|
|
};
|
|
});
|
|
System.get("traceur-runtime@0.0.79/src/runtime/polyfills/Set.js" + '');
|
|
System.registerModule("traceur-runtime@0.0.79/node_modules/rsvp/lib/rsvp/asap.js", [], function() {
|
|
"use strict";
|
|
var __moduleName = "traceur-runtime@0.0.79/node_modules/rsvp/lib/rsvp/asap.js";
|
|
var len = 0;
|
|
function asap(callback, arg) {
|
|
queue[len] = callback;
|
|
queue[len + 1] = arg;
|
|
len += 2;
|
|
if (len === 2) {
|
|
scheduleFlush();
|
|
}
|
|
}
|
|
var $__default = asap;
|
|
var browserGlobal = (typeof window !== 'undefined') ? window : {};
|
|
var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
|
|
var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
|
|
function useNextTick() {
|
|
return function() {
|
|
process.nextTick(flush);
|
|
};
|
|
}
|
|
function useMutationObserver() {
|
|
var iterations = 0;
|
|
var observer = new BrowserMutationObserver(flush);
|
|
var node = document.createTextNode('');
|
|
observer.observe(node, {characterData: true});
|
|
return function() {
|
|
node.data = (iterations = ++iterations % 2);
|
|
};
|
|
}
|
|
function useMessageChannel() {
|
|
var channel = new MessageChannel();
|
|
channel.port1.onmessage = flush;
|
|
return function() {
|
|
channel.port2.postMessage(0);
|
|
};
|
|
}
|
|
function useSetTimeout() {
|
|
return function() {
|
|
setTimeout(flush, 1);
|
|
};
|
|
}
|
|
var queue = new Array(1000);
|
|
function flush() {
|
|
for (var i = 0; i < len; i += 2) {
|
|
var callback = queue[i];
|
|
var arg = queue[i + 1];
|
|
callback(arg);
|
|
queue[i] = undefined;
|
|
queue[i + 1] = undefined;
|
|
}
|
|
len = 0;
|
|
}
|
|
var scheduleFlush;
|
|
if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
|
|
scheduleFlush = useNextTick();
|
|
} else if (BrowserMutationObserver) {
|
|
scheduleFlush = useMutationObserver();
|
|
} else if (isWorker) {
|
|
scheduleFlush = useMessageChannel();
|
|
} else {
|
|
scheduleFlush = useSetTimeout();
|
|
}
|
|
return {get default() {
|
|
return $__default;
|
|
}};
|
|
});
|
|
System.registerModule("traceur-runtime@0.0.79/src/runtime/polyfills/Promise.js", [], function() {
|
|
"use strict";
|
|
var __moduleName = "traceur-runtime@0.0.79/src/runtime/polyfills/Promise.js";
|
|
var async = System.get("traceur-runtime@0.0.79/node_modules/rsvp/lib/rsvp/asap.js").default;
|
|
var registerPolyfill = System.get("traceur-runtime@0.0.79/src/runtime/polyfills/utils.js").registerPolyfill;
|
|
var promiseRaw = {};
|
|
function isPromise(x) {
|
|
return x && typeof x === 'object' && x.status_ !== undefined;
|
|
}
|
|
function idResolveHandler(x) {
|
|
return x;
|
|
}
|
|
function idRejectHandler(x) {
|
|
throw x;
|
|
}
|
|
function chain(promise) {
|
|
var onResolve = arguments[1] !== (void 0) ? arguments[1] : idResolveHandler;
|
|
var onReject = arguments[2] !== (void 0) ? arguments[2] : idRejectHandler;
|
|
var deferred = getDeferred(promise.constructor);
|
|
switch (promise.status_) {
|
|
case undefined:
|
|
throw TypeError;
|
|
case 0:
|
|
promise.onResolve_.push(onResolve, deferred);
|
|
promise.onReject_.push(onReject, deferred);
|
|
break;
|
|
case +1:
|
|
promiseEnqueue(promise.value_, [onResolve, deferred]);
|
|
break;
|
|
case -1:
|
|
promiseEnqueue(promise.value_, [onReject, deferred]);
|
|
break;
|
|
}
|
|
return deferred.promise;
|
|
}
|
|
function getDeferred(C) {
|
|
if (this === $Promise) {
|
|
var promise = promiseInit(new $Promise(promiseRaw));
|
|
return {
|
|
promise: promise,
|
|
resolve: (function(x) {
|
|
promiseResolve(promise, x);
|
|
}),
|
|
reject: (function(r) {
|
|
promiseReject(promise, r);
|
|
})
|
|
};
|
|
} else {
|
|
var result = {};
|
|
result.promise = new C((function(resolve, reject) {
|
|
result.resolve = resolve;
|
|
result.reject = reject;
|
|
}));
|
|
return result;
|
|
}
|
|
}
|
|
function promiseSet(promise, status, value, onResolve, onReject) {
|
|
promise.status_ = status;
|
|
promise.value_ = value;
|
|
promise.onResolve_ = onResolve;
|
|
promise.onReject_ = onReject;
|
|
return promise;
|
|
}
|
|
function promiseInit(promise) {
|
|
return promiseSet(promise, 0, undefined, [], []);
|
|
}
|
|
var Promise = function Promise(resolver) {
|
|
if (resolver === promiseRaw)
|
|
return;
|
|
if (typeof resolver !== 'function')
|
|
throw new TypeError;
|
|
var promise = promiseInit(this);
|
|
try {
|
|
resolver((function(x) {
|
|
promiseResolve(promise, x);
|
|
}), (function(r) {
|
|
promiseReject(promise, r);
|
|
}));
|
|
} catch (e) {
|
|
promiseReject(promise, e);
|
|
}
|
|
};
|
|
($traceurRuntime.createClass)(Promise, {
|
|
catch: function(onReject) {
|
|
return this.then(undefined, onReject);
|
|
},
|
|
then: function(onResolve, onReject) {
|
|
if (typeof onResolve !== 'function')
|
|
onResolve = idResolveHandler;
|
|
if (typeof onReject !== 'function')
|
|
onReject = idRejectHandler;
|
|
var that = this;
|
|
var constructor = this.constructor;
|
|
return chain(this, function(x) {
|
|
x = promiseCoerce(constructor, x);
|
|
return x === that ? onReject(new TypeError) : isPromise(x) ? x.then(onResolve, onReject) : onResolve(x);
|
|
}, onReject);
|
|
}
|
|
}, {
|
|
resolve: function(x) {
|
|
if (this === $Promise) {
|
|
if (isPromise(x)) {
|
|
return x;
|
|
}
|
|
return promiseSet(new $Promise(promiseRaw), +1, x);
|
|
} else {
|
|
return new this(function(resolve, reject) {
|
|
resolve(x);
|
|
});
|
|
}
|
|
},
|
|
reject: function(r) {
|
|
if (this === $Promise) {
|
|
return promiseSet(new $Promise(promiseRaw), -1, r);
|
|
} else {
|
|
return new this((function(resolve, reject) {
|
|
reject(r);
|
|
}));
|
|
}
|
|
},
|
|
all: function(values) {
|
|
var deferred = getDeferred(this);
|
|
var resolutions = [];
|
|
try {
|
|
var count = values.length;
|
|
if (count === 0) {
|
|
deferred.resolve(resolutions);
|
|
} else {
|
|
for (var i = 0; i < values.length; i++) {
|
|
this.resolve(values[i]).then(function(i, x) {
|
|
resolutions[i] = x;
|
|
if (--count === 0)
|
|
deferred.resolve(resolutions);
|
|
}.bind(undefined, i), (function(r) {
|
|
deferred.reject(r);
|
|
}));
|
|
}
|
|
}
|
|
} catch (e) {
|
|
deferred.reject(e);
|
|
}
|
|
return deferred.promise;
|
|
},
|
|
race: function(values) {
|
|
var deferred = getDeferred(this);
|
|
try {
|
|
for (var i = 0; i < values.length; i++) {
|
|
this.resolve(values[i]).then((function(x) {
|
|
deferred.resolve(x);
|
|
}), (function(r) {
|
|
deferred.reject(r);
|
|
}));
|
|
}
|
|
} catch (e) {
|
|
deferred.reject(e);
|
|
}
|
|
return deferred.promise;
|
|
}
|
|
});
|
|
var $Promise = Promise;
|
|
var $PromiseReject = $Promise.reject;
|
|
function promiseResolve(promise, x) {
|
|
promiseDone(promise, +1, x, promise.onResolve_);
|
|
}
|
|
function promiseReject(promise, r) {
|
|
promiseDone(promise, -1, r, promise.onReject_);
|
|
}
|
|
function promiseDone(promise, status, value, reactions) {
|
|
if (promise.status_ !== 0)
|
|
return;
|
|
promiseEnqueue(value, reactions);
|
|
promiseSet(promise, status, value);
|
|
}
|
|
function promiseEnqueue(value, tasks) {
|
|
async((function() {
|
|
for (var i = 0; i < tasks.length; i += 2) {
|
|
promiseHandle(value, tasks[i], tasks[i + 1]);
|
|
}
|
|
}));
|
|
}
|
|
function promiseHandle(value, handler, deferred) {
|
|
try {
|
|
var result = handler(value);
|
|
if (result === deferred.promise)
|
|
throw new TypeError;
|
|
else if (isPromise(result))
|
|
chain(result, deferred.resolve, deferred.reject);
|
|
else
|
|
deferred.resolve(result);
|
|
} catch (e) {
|
|
try {
|
|
deferred.reject(e);
|
|
} catch (e) {}
|
|
}
|
|
}
|
|
var thenableSymbol = '@@thenable';
|
|
function isObject(x) {
|
|
return x && (typeof x === 'object' || typeof x === 'function');
|
|
}
|
|
function promiseCoerce(constructor, x) {
|
|
if (!isPromise(x) && isObject(x)) {
|
|
var then;
|
|
try {
|
|
then = x.then;
|
|
} catch (r) {
|
|
var promise = $PromiseReject.call(constructor, r);
|
|
x[thenableSymbol] = promise;
|
|
return promise;
|
|
}
|
|
if (typeof then === 'function') {
|
|
var p = x[thenableSymbol];
|
|
if (p) {
|
|
return p;
|
|
} else {
|
|
var deferred = getDeferred(constructor);
|
|
x[thenableSymbol] = deferred.promise;
|
|
try {
|
|
then.call(x, deferred.resolve, deferred.reject);
|
|
} catch (r) {
|
|
deferred.reject(r);
|
|
}
|
|
return deferred.promise;
|
|
}
|
|
}
|
|
}
|
|
return x;
|
|
}
|
|
function polyfillPromise(global) {
|
|
if (!global.Promise)
|
|
global.Promise = Promise;
|
|
}
|
|
registerPolyfill(polyfillPromise);
|
|
return {
|
|
get Promise() {
|
|
return Promise;
|
|
},
|
|
get polyfillPromise() {
|
|
return polyfillPromise;
|
|
}
|
|
};
|
|
});
|
|
System.get("traceur-runtime@0.0.79/src/runtime/polyfills/Promise.js" + '');
|
|
System.registerModule("traceur-runtime@0.0.79/src/runtime/polyfills/StringIterator.js", [], function() {
|
|
"use strict";
|
|
var $__2;
|
|
var __moduleName = "traceur-runtime@0.0.79/src/runtime/polyfills/StringIterator.js";
|
|
var $__0 = System.get("traceur-runtime@0.0.79/src/runtime/polyfills/utils.js"),
|
|
createIteratorResultObject = $__0.createIteratorResultObject,
|
|
isObject = $__0.isObject;
|
|
var toProperty = $traceurRuntime.toProperty;
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
var iteratedString = Symbol('iteratedString');
|
|
var stringIteratorNextIndex = Symbol('stringIteratorNextIndex');
|
|
var StringIterator = function StringIterator() {};
|
|
($traceurRuntime.createClass)(StringIterator, ($__2 = {}, Object.defineProperty($__2, "next", {
|
|
value: function() {
|
|
var o = this;
|
|
if (!isObject(o) || !hasOwnProperty.call(o, iteratedString)) {
|
|
throw new TypeError('this must be a StringIterator object');
|
|
}
|
|
var s = o[toProperty(iteratedString)];
|
|
if (s === undefined) {
|
|
return createIteratorResultObject(undefined, true);
|
|
}
|
|
var position = o[toProperty(stringIteratorNextIndex)];
|
|
var len = s.length;
|
|
if (position >= len) {
|
|
o[toProperty(iteratedString)] = undefined;
|
|
return createIteratorResultObject(undefined, true);
|
|
}
|
|
var first = s.charCodeAt(position);
|
|
var resultString;
|
|
if (first < 0xD800 || first > 0xDBFF || position + 1 === len) {
|
|
resultString = String.fromCharCode(first);
|
|
} else {
|
|
var second = s.charCodeAt(position + 1);
|
|
if (second < 0xDC00 || second > 0xDFFF) {
|
|
resultString = String.fromCharCode(first);
|
|
} else {
|
|
resultString = String.fromCharCode(first) + String.fromCharCode(second);
|
|
}
|
|
}
|
|
o[toProperty(stringIteratorNextIndex)] = position + resultString.length;
|
|
return createIteratorResultObject(resultString, false);
|
|
},
|
|
configurable: true,
|
|
enumerable: true,
|
|
writable: true
|
|
}), Object.defineProperty($__2, Symbol.iterator, {
|
|
value: function() {
|
|
return this;
|
|
},
|
|
configurable: true,
|
|
enumerable: true,
|
|
writable: true
|
|
}), $__2), {});
|
|
function createStringIterator(string) {
|
|
var s = String(string);
|
|
var iterator = Object.create(StringIterator.prototype);
|
|
iterator[toProperty(iteratedString)] = s;
|
|
iterator[toProperty(stringIteratorNextIndex)] = 0;
|
|
return iterator;
|
|
}
|
|
return {get createStringIterator() {
|
|
return createStringIterator;
|
|
}};
|
|
});
|
|
System.registerModule("traceur-runtime@0.0.79/src/runtime/polyfills/String.js", [], function() {
|
|
"use strict";
|
|
var __moduleName = "traceur-runtime@0.0.79/src/runtime/polyfills/String.js";
|
|
var createStringIterator = System.get("traceur-runtime@0.0.79/src/runtime/polyfills/StringIterator.js").createStringIterator;
|
|
var $__1 = System.get("traceur-runtime@0.0.79/src/runtime/polyfills/utils.js"),
|
|
maybeAddFunctions = $__1.maybeAddFunctions,
|
|
maybeAddIterator = $__1.maybeAddIterator,
|
|
registerPolyfill = $__1.registerPolyfill;
|
|
var $toString = Object.prototype.toString;
|
|
var $indexOf = String.prototype.indexOf;
|
|
var $lastIndexOf = String.prototype.lastIndexOf;
|
|
function startsWith(search) {
|
|
var string = String(this);
|
|
if (this == null || $toString.call(search) == '[object RegExp]') {
|
|
throw TypeError();
|
|
}
|
|
var stringLength = string.length;
|
|
var searchString = String(search);
|
|
var searchLength = searchString.length;
|
|
var position = arguments.length > 1 ? arguments[1] : undefined;
|
|
var pos = position ? Number(position) : 0;
|
|
if (isNaN(pos)) {
|
|
pos = 0;
|
|
}
|
|
var start = Math.min(Math.max(pos, 0), stringLength);
|
|
return $indexOf.call(string, searchString, pos) == start;
|
|
}
|
|
function endsWith(search) {
|
|
var string = String(this);
|
|
if (this == null || $toString.call(search) == '[object RegExp]') {
|
|
throw TypeError();
|
|
}
|
|
var stringLength = string.length;
|
|
var searchString = String(search);
|
|
var searchLength = searchString.length;
|
|
var pos = stringLength;
|
|
if (arguments.length > 1) {
|
|
var position = arguments[1];
|
|
if (position !== undefined) {
|
|
pos = position ? Number(position) : 0;
|
|
if (isNaN(pos)) {
|
|
pos = 0;
|
|
}
|
|
}
|
|
}
|
|
var end = Math.min(Math.max(pos, 0), stringLength);
|
|
var start = end - searchLength;
|
|
if (start < 0) {
|
|
return false;
|
|
}
|
|
return $lastIndexOf.call(string, searchString, start) == start;
|
|
}
|
|
function includes(search) {
|
|
if (this == null) {
|
|
throw TypeError();
|
|
}
|
|
var string = String(this);
|
|
if (search && $toString.call(search) == '[object RegExp]') {
|
|
throw TypeError();
|
|
}
|
|
var stringLength = string.length;
|
|
var searchString = String(search);
|
|
var searchLength = searchString.length;
|
|
var position = arguments.length > 1 ? arguments[1] : undefined;
|
|
var pos = position ? Number(position) : 0;
|
|
if (pos != pos) {
|
|
pos = 0;
|
|
}
|
|
var start = Math.min(Math.max(pos, 0), stringLength);
|
|
if (searchLength + start > stringLength) {
|
|
return false;
|
|
}
|
|
return $indexOf.call(string, searchString, pos) != -1;
|
|
}
|
|
function repeat(count) {
|
|
if (this == null) {
|
|
throw TypeError();
|
|
}
|
|
var string = String(this);
|
|
var n = count ? Number(count) : 0;
|
|
if (isNaN(n)) {
|
|
n = 0;
|
|
}
|
|
if (n < 0 || n == Infinity) {
|
|
throw RangeError();
|
|
}
|
|
if (n == 0) {
|
|
return '';
|
|
}
|
|
var result = '';
|
|
while (n--) {
|
|
result += string;
|
|
}
|
|
return result;
|
|
}
|
|
function codePointAt(position) {
|
|
if (this == null) {
|
|
throw TypeError();
|
|
}
|
|
var string = String(this);
|
|
var size = string.length;
|
|
var index = position ? Number(position) : 0;
|
|
if (isNaN(index)) {
|
|
index = 0;
|
|
}
|
|
if (index < 0 || index >= size) {
|
|
return undefined;
|
|
}
|
|
var first = string.charCodeAt(index);
|
|
var second;
|
|
if (first >= 0xD800 && first <= 0xDBFF && size > index + 1) {
|
|
second = string.charCodeAt(index + 1);
|
|
if (second >= 0xDC00 && second <= 0xDFFF) {
|
|
return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
|
|
}
|
|
}
|
|
return first;
|
|
}
|
|
function raw(callsite) {
|
|
var raw = callsite.raw;
|
|
var len = raw.length >>> 0;
|
|
if (len === 0)
|
|
return '';
|
|
var s = '';
|
|
var i = 0;
|
|
while (true) {
|
|
s += raw[i];
|
|
if (i + 1 === len)
|
|
return s;
|
|
s += arguments[++i];
|
|
}
|
|
}
|
|
function fromCodePoint() {
|
|
var codeUnits = [];
|
|
var floor = Math.floor;
|
|
var highSurrogate;
|
|
var lowSurrogate;
|
|
var index = -1;
|
|
var length = arguments.length;
|
|
if (!length) {
|
|
return '';
|
|
}
|
|
while (++index < length) {
|
|
var codePoint = Number(arguments[index]);
|
|
if (!isFinite(codePoint) || codePoint < 0 || codePoint > 0x10FFFF || floor(codePoint) != codePoint) {
|
|
throw RangeError('Invalid code point: ' + codePoint);
|
|
}
|
|
if (codePoint <= 0xFFFF) {
|
|
codeUnits.push(codePoint);
|
|
} else {
|
|
codePoint -= 0x10000;
|
|
highSurrogate = (codePoint >> 10) + 0xD800;
|
|
lowSurrogate = (codePoint % 0x400) + 0xDC00;
|
|
codeUnits.push(highSurrogate, lowSurrogate);
|
|
}
|
|
}
|
|
return String.fromCharCode.apply(null, codeUnits);
|
|
}
|
|
function stringPrototypeIterator() {
|
|
var o = $traceurRuntime.checkObjectCoercible(this);
|
|
var s = String(o);
|
|
return createStringIterator(s);
|
|
}
|
|
function polyfillString(global) {
|
|
var String = global.String;
|
|
maybeAddFunctions(String.prototype, ['codePointAt', codePointAt, 'endsWith', endsWith, 'includes', includes, 'repeat', repeat, 'startsWith', startsWith]);
|
|
maybeAddFunctions(String, ['fromCodePoint', fromCodePoint, 'raw', raw]);
|
|
maybeAddIterator(String.prototype, stringPrototypeIterator, Symbol);
|
|
}
|
|
registerPolyfill(polyfillString);
|
|
return {
|
|
get startsWith() {
|
|
return startsWith;
|
|
},
|
|
get endsWith() {
|
|
return endsWith;
|
|
},
|
|
get includes() {
|
|
return includes;
|
|
},
|
|
get repeat() {
|
|
return repeat;
|
|
},
|
|
get codePointAt() {
|
|
return codePointAt;
|
|
},
|
|
get raw() {
|
|
return raw;
|
|
},
|
|
get fromCodePoint() {
|
|
return fromCodePoint;
|
|
},
|
|
get stringPrototypeIterator() {
|
|
return stringPrototypeIterator;
|
|
},
|
|
get polyfillString() {
|
|
return polyfillString;
|
|
}
|
|
};
|
|
});
|
|
System.get("traceur-runtime@0.0.79/src/runtime/polyfills/String.js" + '');
|
|
System.registerModule("traceur-runtime@0.0.79/src/runtime/polyfills/ArrayIterator.js", [], function() {
|
|
"use strict";
|
|
var $__2;
|
|
var __moduleName = "traceur-runtime@0.0.79/src/runtime/polyfills/ArrayIterator.js";
|
|
var $__0 = System.get("traceur-runtime@0.0.79/src/runtime/polyfills/utils.js"),
|
|
toObject = $__0.toObject,
|
|
toUint32 = $__0.toUint32,
|
|
createIteratorResultObject = $__0.createIteratorResultObject;
|
|
var ARRAY_ITERATOR_KIND_KEYS = 1;
|
|
var ARRAY_ITERATOR_KIND_VALUES = 2;
|
|
var ARRAY_ITERATOR_KIND_ENTRIES = 3;
|
|
var ArrayIterator = function ArrayIterator() {};
|
|
($traceurRuntime.createClass)(ArrayIterator, ($__2 = {}, Object.defineProperty($__2, "next", {
|
|
value: function() {
|
|
var iterator = toObject(this);
|
|
var array = iterator.iteratorObject_;
|
|
if (!array) {
|
|
throw new TypeError('Object is not an ArrayIterator');
|
|
}
|
|
var index = iterator.arrayIteratorNextIndex_;
|
|
var itemKind = iterator.arrayIterationKind_;
|
|
var length = toUint32(array.length);
|
|
if (index >= length) {
|
|
iterator.arrayIteratorNextIndex_ = Infinity;
|
|
return createIteratorResultObject(undefined, true);
|
|
}
|
|
iterator.arrayIteratorNextIndex_ = index + 1;
|
|
if (itemKind == ARRAY_ITERATOR_KIND_VALUES)
|
|
return createIteratorResultObject(array[index], false);
|
|
if (itemKind == ARRAY_ITERATOR_KIND_ENTRIES)
|
|
return createIteratorResultObject([index, array[index]], false);
|
|
return createIteratorResultObject(index, false);
|
|
},
|
|
configurable: true,
|
|
enumerable: true,
|
|
writable: true
|
|
}), Object.defineProperty($__2, Symbol.iterator, {
|
|
value: function() {
|
|
return this;
|
|
},
|
|
configurable: true,
|
|
enumerable: true,
|
|
writable: true
|
|
}), $__2), {});
|
|
function createArrayIterator(array, kind) {
|
|
var object = toObject(array);
|
|
var iterator = new ArrayIterator;
|
|
iterator.iteratorObject_ = object;
|
|
iterator.arrayIteratorNextIndex_ = 0;
|
|
iterator.arrayIterationKind_ = kind;
|
|
return iterator;
|
|
}
|
|
function entries() {
|
|
return createArrayIterator(this, ARRAY_ITERATOR_KIND_ENTRIES);
|
|
}
|
|
function keys() {
|
|
return createArrayIterator(this, ARRAY_ITERATOR_KIND_KEYS);
|
|
}
|
|
function values() {
|
|
return createArrayIterator(this, ARRAY_ITERATOR_KIND_VALUES);
|
|
}
|
|
return {
|
|
get entries() {
|
|
return entries;
|
|
},
|
|
get keys() {
|
|
return keys;
|
|
},
|
|
get values() {
|
|
return values;
|
|
}
|
|
};
|
|
});
|
|
System.registerModule("traceur-runtime@0.0.79/src/runtime/polyfills/Array.js", [], function() {
|
|
"use strict";
|
|
var __moduleName = "traceur-runtime@0.0.79/src/runtime/polyfills/Array.js";
|
|
var $__0 = System.get("traceur-runtime@0.0.79/src/runtime/polyfills/ArrayIterator.js"),
|
|
entries = $__0.entries,
|
|
keys = $__0.keys,
|
|
values = $__0.values;
|
|
var $__1 = System.get("traceur-runtime@0.0.79/src/runtime/polyfills/utils.js"),
|
|
checkIterable = $__1.checkIterable,
|
|
isCallable = $__1.isCallable,
|
|
isConstructor = $__1.isConstructor,
|
|
maybeAddFunctions = $__1.maybeAddFunctions,
|
|
maybeAddIterator = $__1.maybeAddIterator,
|
|
registerPolyfill = $__1.registerPolyfill,
|
|
toInteger = $__1.toInteger,
|
|
toLength = $__1.toLength,
|
|
toObject = $__1.toObject;
|
|
function from(arrLike) {
|
|
var mapFn = arguments[1];
|
|
var thisArg = arguments[2];
|
|
var C = this;
|
|
var items = toObject(arrLike);
|
|
var mapping = mapFn !== undefined;
|
|
var k = 0;
|
|
var arr,
|
|
len;
|
|
if (mapping && !isCallable(mapFn)) {
|
|
throw TypeError();
|
|
}
|
|
if (checkIterable(items)) {
|
|
arr = isConstructor(C) ? new C() : [];
|
|
for (var $__2 = items[$traceurRuntime.toProperty(Symbol.iterator)](),
|
|
$__3; !($__3 = $__2.next()).done; ) {
|
|
var item = $__3.value;
|
|
{
|
|
if (mapping) {
|
|
arr[k] = mapFn.call(thisArg, item, k);
|
|
} else {
|
|
arr[k] = item;
|
|
}
|
|
k++;
|
|
}
|
|
}
|
|
arr.length = k;
|
|
return arr;
|
|
}
|
|
len = toLength(items.length);
|
|
arr = isConstructor(C) ? new C(len) : new Array(len);
|
|
for (; k < len; k++) {
|
|
if (mapping) {
|
|
arr[k] = typeof thisArg === 'undefined' ? mapFn(items[k], k) : mapFn.call(thisArg, items[k], k);
|
|
} else {
|
|
arr[k] = items[k];
|
|
}
|
|
}
|
|
arr.length = len;
|
|
return arr;
|
|
}
|
|
function of() {
|
|
for (var items = [],
|
|
$__4 = 0; $__4 < arguments.length; $__4++)
|
|
items[$__4] = arguments[$__4];
|
|
var C = this;
|
|
var len = items.length;
|
|
var arr = isConstructor(C) ? new C(len) : new Array(len);
|
|
for (var k = 0; k < len; k++) {
|
|
arr[k] = items[k];
|
|
}
|
|
arr.length = len;
|
|
return arr;
|
|
}
|
|
function fill(value) {
|
|
var start = arguments[1] !== (void 0) ? arguments[1] : 0;
|
|
var end = arguments[2];
|
|
var object = toObject(this);
|
|
var len = toLength(object.length);
|
|
var fillStart = toInteger(start);
|
|
var fillEnd = end !== undefined ? toInteger(end) : len;
|
|
fillStart = fillStart < 0 ? Math.max(len + fillStart, 0) : Math.min(fillStart, len);
|
|
fillEnd = fillEnd < 0 ? Math.max(len + fillEnd, 0) : Math.min(fillEnd, len);
|
|
while (fillStart < fillEnd) {
|
|
object[fillStart] = value;
|
|
fillStart++;
|
|
}
|
|
return object;
|
|
}
|
|
function find(predicate) {
|
|
var thisArg = arguments[1];
|
|
return findHelper(this, predicate, thisArg);
|
|
}
|
|
function findIndex(predicate) {
|
|
var thisArg = arguments[1];
|
|
return findHelper(this, predicate, thisArg, true);
|
|
}
|
|
function findHelper(self, predicate) {
|
|
var thisArg = arguments[2];
|
|
var returnIndex = arguments[3] !== (void 0) ? arguments[3] : false;
|
|
var object = toObject(self);
|
|
var len = toLength(object.length);
|
|
if (!isCallable(predicate)) {
|
|
throw TypeError();
|
|
}
|
|
for (var i = 0; i < len; i++) {
|
|
var value = object[i];
|
|
if (predicate.call(thisArg, value, i, object)) {
|
|
return returnIndex ? i : value;
|
|
}
|
|
}
|
|
return returnIndex ? -1 : undefined;
|
|
}
|
|
function polyfillArray(global) {
|
|
var $__5 = global,
|
|
Array = $__5.Array,
|
|
Object = $__5.Object,
|
|
Symbol = $__5.Symbol;
|
|
maybeAddFunctions(Array.prototype, ['entries', entries, 'keys', keys, 'values', values, 'fill', fill, 'find', find, 'findIndex', findIndex]);
|
|
maybeAddFunctions(Array, ['from', from, 'of', of]);
|
|
maybeAddIterator(Array.prototype, values, Symbol);
|
|
maybeAddIterator(Object.getPrototypeOf([].values()), function() {
|
|
return this;
|
|
}, Symbol);
|
|
}
|
|
registerPolyfill(polyfillArray);
|
|
return {
|
|
get from() {
|
|
return from;
|
|
},
|
|
get of() {
|
|
return of;
|
|
},
|
|
get fill() {
|
|
return fill;
|
|
},
|
|
get find() {
|
|
return find;
|
|
},
|
|
get findIndex() {
|
|
return findIndex;
|
|
},
|
|
get polyfillArray() {
|
|
return polyfillArray;
|
|
}
|
|
};
|
|
});
|
|
System.get("traceur-runtime@0.0.79/src/runtime/polyfills/Array.js" + '');
|
|
System.registerModule("traceur-runtime@0.0.79/src/runtime/polyfills/Object.js", [], function() {
|
|
"use strict";
|
|
var __moduleName = "traceur-runtime@0.0.79/src/runtime/polyfills/Object.js";
|
|
var $__0 = System.get("traceur-runtime@0.0.79/src/runtime/polyfills/utils.js"),
|
|
maybeAddFunctions = $__0.maybeAddFunctions,
|
|
registerPolyfill = $__0.registerPolyfill;
|
|
var $__1 = $traceurRuntime,
|
|
defineProperty = $__1.defineProperty,
|
|
getOwnPropertyDescriptor = $__1.getOwnPropertyDescriptor,
|
|
getOwnPropertyNames = $__1.getOwnPropertyNames,
|
|
isPrivateName = $__1.isPrivateName,
|
|
keys = $__1.keys;
|
|
function is(left, right) {
|
|
if (left === right)
|
|
return left !== 0 || 1 / left === 1 / right;
|
|
return left !== left && right !== right;
|
|
}
|
|
function assign(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
var props = source == null ? [] : keys(source);
|
|
var p,
|
|
length = props.length;
|
|
for (p = 0; p < length; p++) {
|
|
var name = props[p];
|
|
if (isPrivateName(name))
|
|
continue;
|
|
target[name] = source[name];
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
function mixin(target, source) {
|
|
var props = getOwnPropertyNames(source);
|
|
var p,
|
|
descriptor,
|
|
length = props.length;
|
|
for (p = 0; p < length; p++) {
|
|
var name = props[p];
|
|
if (isPrivateName(name))
|
|
continue;
|
|
descriptor = getOwnPropertyDescriptor(source, props[p]);
|
|
defineProperty(target, props[p], descriptor);
|
|
}
|
|
return target;
|
|
}
|
|
function polyfillObject(global) {
|
|
var Object = global.Object;
|
|
maybeAddFunctions(Object, ['assign', assign, 'is', is, 'mixin', mixin]);
|
|
}
|
|
registerPolyfill(polyfillObject);
|
|
return {
|
|
get is() {
|
|
return is;
|
|
},
|
|
get assign() {
|
|
return assign;
|
|
},
|
|
get mixin() {
|
|
return mixin;
|
|
},
|
|
get polyfillObject() {
|
|
return polyfillObject;
|
|
}
|
|
};
|
|
});
|
|
System.get("traceur-runtime@0.0.79/src/runtime/polyfills/Object.js" + '');
|
|
System.registerModule("traceur-runtime@0.0.79/src/runtime/polyfills/Number.js", [], function() {
|
|
"use strict";
|
|
var __moduleName = "traceur-runtime@0.0.79/src/runtime/polyfills/Number.js";
|
|
var $__0 = System.get("traceur-runtime@0.0.79/src/runtime/polyfills/utils.js"),
|
|
isNumber = $__0.isNumber,
|
|
maybeAddConsts = $__0.maybeAddConsts,
|
|
maybeAddFunctions = $__0.maybeAddFunctions,
|
|
registerPolyfill = $__0.registerPolyfill,
|
|
toInteger = $__0.toInteger;
|
|
var $abs = Math.abs;
|
|
var $isFinite = isFinite;
|
|
var $isNaN = isNaN;
|
|
var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
|
|
var MIN_SAFE_INTEGER = -Math.pow(2, 53) + 1;
|
|
var EPSILON = Math.pow(2, -52);
|
|
function NumberIsFinite(number) {
|
|
return isNumber(number) && $isFinite(number);
|
|
}
|
|
;
|
|
function isInteger(number) {
|
|
return NumberIsFinite(number) && toInteger(number) === number;
|
|
}
|
|
function NumberIsNaN(number) {
|
|
return isNumber(number) && $isNaN(number);
|
|
}
|
|
;
|
|
function isSafeInteger(number) {
|
|
if (NumberIsFinite(number)) {
|
|
var integral = toInteger(number);
|
|
if (integral === number)
|
|
return $abs(integral) <= MAX_SAFE_INTEGER;
|
|
}
|
|
return false;
|
|
}
|
|
function polyfillNumber(global) {
|
|
var Number = global.Number;
|
|
maybeAddConsts(Number, ['MAX_SAFE_INTEGER', MAX_SAFE_INTEGER, 'MIN_SAFE_INTEGER', MIN_SAFE_INTEGER, 'EPSILON', EPSILON]);
|
|
maybeAddFunctions(Number, ['isFinite', NumberIsFinite, 'isInteger', isInteger, 'isNaN', NumberIsNaN, 'isSafeInteger', isSafeInteger]);
|
|
}
|
|
registerPolyfill(polyfillNumber);
|
|
return {
|
|
get MAX_SAFE_INTEGER() {
|
|
return MAX_SAFE_INTEGER;
|
|
},
|
|
get MIN_SAFE_INTEGER() {
|
|
return MIN_SAFE_INTEGER;
|
|
},
|
|
get EPSILON() {
|
|
return EPSILON;
|
|
},
|
|
get isFinite() {
|
|
return NumberIsFinite;
|
|
},
|
|
get isInteger() {
|
|
return isInteger;
|
|
},
|
|
get isNaN() {
|
|
return NumberIsNaN;
|
|
},
|
|
get isSafeInteger() {
|
|
return isSafeInteger;
|
|
},
|
|
get polyfillNumber() {
|
|
return polyfillNumber;
|
|
}
|
|
};
|
|
});
|
|
System.get("traceur-runtime@0.0.79/src/runtime/polyfills/Number.js" + '');
|
|
System.registerModule("traceur-runtime@0.0.79/src/runtime/polyfills/polyfills.js", [], function() {
|
|
"use strict";
|
|
var __moduleName = "traceur-runtime@0.0.79/src/runtime/polyfills/polyfills.js";
|
|
var polyfillAll = System.get("traceur-runtime@0.0.79/src/runtime/polyfills/utils.js").polyfillAll;
|
|
polyfillAll(Reflect.global);
|
|
var setupGlobals = $traceurRuntime.setupGlobals;
|
|
$traceurRuntime.setupGlobals = function(global) {
|
|
setupGlobals(global);
|
|
polyfillAll(global);
|
|
};
|
|
return {};
|
|
});
|
|
System.get("traceur-runtime@0.0.79/src/runtime/polyfills/polyfills.js" + '');
|