Commit f14d0421 authored by Lwd's avatar Lwd

commit

parent a9489a3b
...@@ -70,6 +70,9 @@ cc.Class({ ...@@ -70,6 +70,9 @@ cc.Class({
}, },
init: function () { init: function () {
var canvaSize = this.findCanvas(); var canvaSize = this.findCanvas();
cc.director._scene.width = canvaSize.width;
cc.director._scene.height = canvaSize.height;
var diff = canvaSize.width / canvaSize.height; var diff = canvaSize.width / canvaSize.height;
var bili = 750 / 1334; var bili = 750 / 1334;
if (diff > bili) { if (diff > bili) {
......
...@@ -5,723 +5,725 @@ ...@@ -5,723 +5,725 @@
* LICENSE file in the root directory of this source tree. * LICENSE file in the root directory of this source tree.
*/ */
!(function(global) { cc.sys.capabilities["touches"] = true;
"use strict";
!(function (global) {
var Op = Object.prototype; "use strict";
var hasOwn = Op.hasOwnProperty;
var undefined; // More compressible than void 0. var Op = Object.prototype;
var $Symbol = typeof Symbol === "function" ? Symbol : {}; var hasOwn = Op.hasOwnProperty;
var iteratorSymbol = $Symbol.iterator || "@@iterator"; var undefined; // More compressible than void 0.
var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator"; var $Symbol = typeof Symbol === "function" ? Symbol : {};
var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; var iteratorSymbol = $Symbol.iterator || "@@iterator";
var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
var inModule = typeof module === "object"; var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
var runtime = global.regeneratorRuntime;
if (runtime) { var inModule = typeof module === "object";
if (inModule) { var runtime = global.regeneratorRuntime;
// If regeneratorRuntime is defined globally and we're in a module, if (runtime) {
// make the exports object identical to regeneratorRuntime. if (inModule) {
module.exports = runtime; // If regeneratorRuntime is defined globally and we're in a module,
} // make the exports object identical to regeneratorRuntime.
// Don't bother evaluating the rest of this file if the runtime was module.exports = runtime;
// already defined globally. }
return; // Don't bother evaluating the rest of this file if the runtime was
} // already defined globally.
return;
// Define the runtime globally (as expected by generated code) as either }
// module.exports (if we're in a module) or a new, empty object.
runtime = global.regeneratorRuntime = inModule ? module.exports : {}; // Define the runtime globally (as expected by generated code) as either
// module.exports (if we're in a module) or a new, empty object.
function wrap(innerFn, outerFn, self, tryLocsList) { runtime = global.regeneratorRuntime = inModule ? module.exports : {};
// If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator; function wrap(innerFn, outerFn, self, tryLocsList) {
var generator = Object.create(protoGenerator.prototype); // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
var context = new Context(tryLocsList || []); var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
var generator = Object.create(protoGenerator.prototype);
// The ._invoke method unifies the implementations of the .next, var context = new Context(tryLocsList || []);
// .throw, and .return methods.
generator._invoke = makeInvokeMethod(innerFn, self, context); // The ._invoke method unifies the implementations of the .next,
// .throw, and .return methods.
return generator; generator._invoke = makeInvokeMethod(innerFn, self, context);
}
runtime.wrap = wrap; return generator;
}
// Try/catch helper to minimize deoptimizations. Returns a completion runtime.wrap = wrap;
// record like context.tryEntries[i].completion. This interface could
// have been (and was previously) designed to take a closure to be // Try/catch helper to minimize deoptimizations. Returns a completion
// invoked without arguments, but in all the cases we care about we // record like context.tryEntries[i].completion. This interface could
// already have an existing method we want to call, so there's no need // have been (and was previously) designed to take a closure to be
// to create a new function object. We can even get away with assuming // invoked without arguments, but in all the cases we care about we
// the method takes exactly one argument, since that happens to be true // already have an existing method we want to call, so there's no need
// in every case, so we don't have to touch the arguments object. The // to create a new function object. We can even get away with assuming
// only additional allocation required is the completion record, which // the method takes exactly one argument, since that happens to be true
// has a stable shape and so hopefully should be cheap to allocate. // in every case, so we don't have to touch the arguments object. The
function tryCatch(fn, obj, arg) { // only additional allocation required is the completion record, which
try { // has a stable shape and so hopefully should be cheap to allocate.
return { type: "normal", arg: fn.call(obj, arg) }; function tryCatch(fn, obj, arg) {
} catch (err) { try {
return { type: "throw", arg: err }; return { type: "normal", arg: fn.call(obj, arg) };
} } catch (err) {
} return { type: "throw", arg: err };
}
var GenStateSuspendedStart = "suspendedStart"; }
var GenStateSuspendedYield = "suspendedYield";
var GenStateExecuting = "executing"; var GenStateSuspendedStart = "suspendedStart";
var GenStateCompleted = "completed"; var GenStateSuspendedYield = "suspendedYield";
var GenStateExecuting = "executing";
// Returning this object from the innerFn has the same effect as var GenStateCompleted = "completed";
// breaking out of the dispatch switch statement.
var ContinueSentinel = {}; // Returning this object from the innerFn has the same effect as
// breaking out of the dispatch switch statement.
// Dummy constructor functions that we use as the .constructor and var ContinueSentinel = {};
// .constructor.prototype properties for functions that return Generator
// objects. For full spec compliance, you may wish to configure your // Dummy constructor functions that we use as the .constructor and
// minifier not to mangle the names of these two functions. // .constructor.prototype properties for functions that return Generator
function Generator() {} // objects. For full spec compliance, you may wish to configure your
function GeneratorFunction() {} // minifier not to mangle the names of these two functions.
function GeneratorFunctionPrototype() {} function Generator() { }
function GeneratorFunction() { }
// This is a polyfill for %IteratorPrototype% for environments that function GeneratorFunctionPrototype() { }
// don't natively support it.
var IteratorPrototype = {}; // This is a polyfill for %IteratorPrototype% for environments that
IteratorPrototype[iteratorSymbol] = function () { // don't natively support it.
return this; var IteratorPrototype = {};
}; IteratorPrototype[iteratorSymbol] = function () {
return this;
var getProto = Object.getPrototypeOf; };
var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
if (NativeIteratorPrototype && var getProto = Object.getPrototypeOf;
NativeIteratorPrototype !== Op && var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) { if (NativeIteratorPrototype &&
// This environment has a native %IteratorPrototype%; use it instead NativeIteratorPrototype !== Op &&
// of the polyfill. hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
IteratorPrototype = NativeIteratorPrototype; // This environment has a native %IteratorPrototype%; use it instead
} // of the polyfill.
IteratorPrototype = NativeIteratorPrototype;
var Gp = GeneratorFunctionPrototype.prototype = }
Generator.prototype = Object.create(IteratorPrototype);
GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype; var Gp = GeneratorFunctionPrototype.prototype =
GeneratorFunctionPrototype.constructor = GeneratorFunction; Generator.prototype = Object.create(IteratorPrototype);
GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
GeneratorFunction.displayName = "GeneratorFunction"; GeneratorFunctionPrototype.constructor = GeneratorFunction;
GeneratorFunctionPrototype[toStringTagSymbol] =
// Helper for defining the .next, .throw, and .return methods of the GeneratorFunction.displayName = "GeneratorFunction";
// Iterator interface in terms of a single ._invoke method.
function defineIteratorMethods(prototype) { // Helper for defining the .next, .throw, and .return methods of the
["next", "throw", "return"].forEach(function(method) { // Iterator interface in terms of a single ._invoke method.
prototype[method] = function(arg) { function defineIteratorMethods(prototype) {
return this._invoke(method, arg); ["next", "throw", "return"].forEach(function (method) {
}; prototype[method] = function (arg) {
}); return this._invoke(method, arg);
} };
});
runtime.isGeneratorFunction = function(genFun) { }
var ctor = typeof genFun === "function" && genFun.constructor;
return ctor runtime.isGeneratorFunction = function (genFun) {
? ctor === GeneratorFunction || var ctor = typeof genFun === "function" && genFun.constructor;
// For the native GeneratorFunction constructor, the best we can return ctor
// do is to check its .name property. ? ctor === GeneratorFunction ||
(ctor.displayName || ctor.name) === "GeneratorFunction" // For the native GeneratorFunction constructor, the best we can
: false; // do is to check its .name property.
}; (ctor.displayName || ctor.name) === "GeneratorFunction"
: false;
runtime.mark = function(genFun) { };
if (Object.setPrototypeOf) {
Object.setPrototypeOf(genFun, GeneratorFunctionPrototype); runtime.mark = function (genFun) {
} else { if (Object.setPrototypeOf) {
genFun.__proto__ = GeneratorFunctionPrototype; Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
if (!(toStringTagSymbol in genFun)) { } else {
genFun[toStringTagSymbol] = "GeneratorFunction"; genFun.__proto__ = GeneratorFunctionPrototype;
} if (!(toStringTagSymbol in genFun)) {
} genFun[toStringTagSymbol] = "GeneratorFunction";
genFun.prototype = Object.create(Gp); }
return genFun; }
}; genFun.prototype = Object.create(Gp);
return genFun;
// Within the body of any async function, `await x` is transformed to };
// `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
// `hasOwn.call(value, "__await")` to determine if the yielded value is // Within the body of any async function, `await x` is transformed to
// meant to be awaited. // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
runtime.awrap = function(arg) { // `hasOwn.call(value, "__await")` to determine if the yielded value is
return { __await: arg }; // meant to be awaited.
}; runtime.awrap = function (arg) {
return { __await: arg };
function AsyncIterator(generator) { };
function invoke(method, arg, resolve, reject) {
var record = tryCatch(generator[method], generator, arg); function AsyncIterator(generator) {
if (record.type === "throw") { function invoke(method, arg, resolve, reject) {
reject(record.arg); var record = tryCatch(generator[method], generator, arg);
} else { if (record.type === "throw") {
var result = record.arg; reject(record.arg);
var value = result.value; } else {
if (value && var result = record.arg;
typeof value === "object" && var value = result.value;
hasOwn.call(value, "__await")) { if (value &&
return Promise.resolve(value.__await).then(function(value) { typeof value === "object" &&
invoke("next", value, resolve, reject); hasOwn.call(value, "__await")) {
}, function(err) { return Promise.resolve(value.__await).then(function (value) {
invoke("throw", err, resolve, reject); invoke("next", value, resolve, reject);
}); }, function (err) {
} invoke("throw", err, resolve, reject);
});
return Promise.resolve(value).then(function(unwrapped) { }
// When a yielded Promise is resolved, its final value becomes
// the .value of the Promise<{value,done}> result for the return Promise.resolve(value).then(function (unwrapped) {
// current iteration. If the Promise is rejected, however, the // When a yielded Promise is resolved, its final value becomes
// result for this iteration will be rejected with the same // the .value of the Promise<{value,done}> result for the
// reason. Note that rejections of yielded Promises are not // current iteration. If the Promise is rejected, however, the
// thrown back into the generator function, as is the case // result for this iteration will be rejected with the same
// when an awaited Promise is rejected. This difference in // reason. Note that rejections of yielded Promises are not
// behavior between yield and await is important, because it // thrown back into the generator function, as is the case
// allows the consumer to decide what to do with the yielded // when an awaited Promise is rejected. This difference in
// rejection (swallow it and continue, manually .throw it back // behavior between yield and await is important, because it
// into the generator, abandon iteration, whatever). With // allows the consumer to decide what to do with the yielded
// await, by contrast, there is no opportunity to examine the // rejection (swallow it and continue, manually .throw it back
// rejection reason outside the generator function, so the // into the generator, abandon iteration, whatever). With
// only option is to throw it from the await expression, and // await, by contrast, there is no opportunity to examine the
// let the generator function handle the exception. // rejection reason outside the generator function, so the
result.value = unwrapped; // only option is to throw it from the await expression, and
resolve(result); // let the generator function handle the exception.
}, reject); result.value = unwrapped;
} resolve(result);
} }, reject);
}
var previousPromise; }
function enqueue(method, arg) { var previousPromise;
function callInvokeWithMethodAndArg() {
return new Promise(function(resolve, reject) { function enqueue(method, arg) {
invoke(method, arg, resolve, reject); function callInvokeWithMethodAndArg() {
}); return new Promise(function (resolve, reject) {
} invoke(method, arg, resolve, reject);
});
return previousPromise = }
// If enqueue has been called before, then we want to wait until
// all previous Promises have been resolved before calling invoke, return previousPromise =
// so that results are always delivered in the correct order. If // If enqueue has been called before, then we want to wait until
// enqueue has not been called before, then it is important to // all previous Promises have been resolved before calling invoke,
// call invoke immediately, without waiting on a callback to fire, // so that results are always delivered in the correct order. If
// so that the async generator function has the opportunity to do // enqueue has not been called before, then it is important to
// any necessary setup in a predictable way. This predictability // call invoke immediately, without waiting on a callback to fire,
// is why the Promise constructor synchronously invokes its // so that the async generator function has the opportunity to do
// executor callback, and why async functions synchronously // any necessary setup in a predictable way. This predictability
// execute code before the first await. Since we implement simple // is why the Promise constructor synchronously invokes its
// async functions in terms of async generators, it is especially // executor callback, and why async functions synchronously
// important to get this right, even though it requires care. // execute code before the first await. Since we implement simple
previousPromise ? previousPromise.then( // async functions in terms of async generators, it is especially
callInvokeWithMethodAndArg, // important to get this right, even though it requires care.
// Avoid propagating failures to Promises returned by later previousPromise ? previousPromise.then(
// invocations of the iterator. callInvokeWithMethodAndArg,
callInvokeWithMethodAndArg // Avoid propagating failures to Promises returned by later
) : callInvokeWithMethodAndArg(); // invocations of the iterator.
} callInvokeWithMethodAndArg
) : callInvokeWithMethodAndArg();
// Define the unified helper method that is used to implement .next, }
// .throw, and .return (see defineIteratorMethods).
this._invoke = enqueue; // Define the unified helper method that is used to implement .next,
} // .throw, and .return (see defineIteratorMethods).
this._invoke = enqueue;
defineIteratorMethods(AsyncIterator.prototype); }
AsyncIterator.prototype[asyncIteratorSymbol] = function () {
return this; defineIteratorMethods(AsyncIterator.prototype);
}; AsyncIterator.prototype[asyncIteratorSymbol] = function () {
runtime.AsyncIterator = AsyncIterator; return this;
};
// Note that simple async functions are implemented on top of runtime.AsyncIterator = AsyncIterator;
// AsyncIterator objects; they just return a Promise for the value of
// the final result produced by the iterator. // Note that simple async functions are implemented on top of
runtime.async = function(innerFn, outerFn, self, tryLocsList) { // AsyncIterator objects; they just return a Promise for the value of
var iter = new AsyncIterator( // the final result produced by the iterator.
wrap(innerFn, outerFn, self, tryLocsList) runtime.async = function (innerFn, outerFn, self, tryLocsList) {
); var iter = new AsyncIterator(
wrap(innerFn, outerFn, self, tryLocsList)
return runtime.isGeneratorFunction(outerFn) );
? iter // If outerFn is a generator, return the full iterator.
: iter.next().then(function(result) { return runtime.isGeneratorFunction(outerFn)
return result.done ? result.value : iter.next(); ? iter // If outerFn is a generator, return the full iterator.
}); : iter.next().then(function (result) {
}; return result.done ? result.value : iter.next();
});
function makeInvokeMethod(innerFn, self, context) { };
var state = GenStateSuspendedStart;
function makeInvokeMethod(innerFn, self, context) {
return function invoke(method, arg) { var state = GenStateSuspendedStart;
if (state === GenStateExecuting) {
throw new Error("Generator is already running"); return function invoke(method, arg) {
} if (state === GenStateExecuting) {
throw new Error("Generator is already running");
if (state === GenStateCompleted) { }
if (method === "throw") {
throw arg; if (state === GenStateCompleted) {
} if (method === "throw") {
throw arg;
// Be forgiving, per 25.3.3.3.3 of the spec: }
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
return doneResult(); // Be forgiving, per 25.3.3.3.3 of the spec:
} // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
return doneResult();
context.method = method; }
context.arg = arg;
context.method = method;
while (true) { context.arg = arg;
var delegate = context.delegate;
if (delegate) { while (true) {
var delegateResult = maybeInvokeDelegate(delegate, context); var delegate = context.delegate;
if (delegateResult) { if (delegate) {
if (delegateResult === ContinueSentinel) continue; var delegateResult = maybeInvokeDelegate(delegate, context);
return delegateResult; if (delegateResult) {
} if (delegateResult === ContinueSentinel) continue;
} return delegateResult;
}
if (context.method === "next") { }
// Setting context._sent for legacy support of Babel's
// function.sent implementation. if (context.method === "next") {
context.sent = context._sent = context.arg; // Setting context._sent for legacy support of Babel's
// function.sent implementation.
} else if (context.method === "throw") { context.sent = context._sent = context.arg;
if (state === GenStateSuspendedStart) {
state = GenStateCompleted; } else if (context.method === "throw") {
throw context.arg; if (state === GenStateSuspendedStart) {
} state = GenStateCompleted;
throw context.arg;
context.dispatchException(context.arg); }
} else if (context.method === "return") { context.dispatchException(context.arg);
context.abrupt("return", context.arg);
} } else if (context.method === "return") {
context.abrupt("return", context.arg);
state = GenStateExecuting; }
var record = tryCatch(innerFn, self, context); state = GenStateExecuting;
if (record.type === "normal") {
// If an exception is thrown from innerFn, we leave state === var record = tryCatch(innerFn, self, context);
// GenStateExecuting and loop back for another invocation. if (record.type === "normal") {
state = context.done // If an exception is thrown from innerFn, we leave state ===
? GenStateCompleted // GenStateExecuting and loop back for another invocation.
: GenStateSuspendedYield; state = context.done
? GenStateCompleted
if (record.arg === ContinueSentinel) { : GenStateSuspendedYield;
continue;
} if (record.arg === ContinueSentinel) {
continue;
return { }
value: record.arg,
done: context.done return {
}; value: record.arg,
done: context.done
} else if (record.type === "throw") { };
state = GenStateCompleted;
// Dispatch the exception by looping back around to the } else if (record.type === "throw") {
// context.dispatchException(context.arg) call above. state = GenStateCompleted;
context.method = "throw"; // Dispatch the exception by looping back around to the
context.arg = record.arg; // context.dispatchException(context.arg) call above.
} context.method = "throw";
} context.arg = record.arg;
}; }
} }
};
// Call delegate.iterator[context.method](context.arg) and handle the }
// result, either by returning a { value, done } result from the
// delegate iterator, or by modifying context.method and context.arg, // Call delegate.iterator[context.method](context.arg) and handle the
// setting context.delegate to null, and returning the ContinueSentinel. // result, either by returning a { value, done } result from the
function maybeInvokeDelegate(delegate, context) { // delegate iterator, or by modifying context.method and context.arg,
var method = delegate.iterator[context.method]; // setting context.delegate to null, and returning the ContinueSentinel.
if (method === undefined) { function maybeInvokeDelegate(delegate, context) {
// A .throw or .return when the delegate iterator has no .throw var method = delegate.iterator[context.method];
// method always terminates the yield* loop. if (method === undefined) {
context.delegate = null; // A .throw or .return when the delegate iterator has no .throw
// method always terminates the yield* loop.
if (context.method === "throw") { context.delegate = null;
if (delegate.iterator.return) {
// If the delegate iterator has a return method, give it a if (context.method === "throw") {
// chance to clean up. if (delegate.iterator.return) {
context.method = "return"; // If the delegate iterator has a return method, give it a
context.arg = undefined; // chance to clean up.
maybeInvokeDelegate(delegate, context); context.method = "return";
context.arg = undefined;
if (context.method === "throw") { maybeInvokeDelegate(delegate, context);
// If maybeInvokeDelegate(context) changed context.method from
// "return" to "throw", let that override the TypeError below. if (context.method === "throw") {
return ContinueSentinel; // If maybeInvokeDelegate(context) changed context.method from
} // "return" to "throw", let that override the TypeError below.
} return ContinueSentinel;
}
context.method = "throw"; }
context.arg = new TypeError(
"The iterator does not provide a 'throw' method"); context.method = "throw";
} context.arg = new TypeError(
"The iterator does not provide a 'throw' method");
return ContinueSentinel; }
}
return ContinueSentinel;
var record = tryCatch(method, delegate.iterator, context.arg); }
if (record.type === "throw") { var record = tryCatch(method, delegate.iterator, context.arg);
context.method = "throw";
context.arg = record.arg; if (record.type === "throw") {
context.delegate = null; context.method = "throw";
return ContinueSentinel; context.arg = record.arg;
} context.delegate = null;
return ContinueSentinel;
var info = record.arg; }
if (! info) { var info = record.arg;
context.method = "throw";
context.arg = new TypeError("iterator result is not an object"); if (!info) {
context.delegate = null; context.method = "throw";
return ContinueSentinel; context.arg = new TypeError("iterator result is not an object");
} context.delegate = null;
return ContinueSentinel;
if (info.done) { }
// Assign the result of the finished delegate to the temporary
// variable specified by delegate.resultName (see delegateYield). if (info.done) {
context[delegate.resultName] = info.value; // Assign the result of the finished delegate to the temporary
// variable specified by delegate.resultName (see delegateYield).
// Resume execution at the desired location (see delegateYield). context[delegate.resultName] = info.value;
context.next = delegate.nextLoc;
// Resume execution at the desired location (see delegateYield).
// If context.method was "throw" but the delegate handled the context.next = delegate.nextLoc;
// exception, let the outer generator proceed normally. If
// context.method was "next", forget context.arg since it has been // If context.method was "throw" but the delegate handled the
// "consumed" by the delegate iterator. If context.method was // exception, let the outer generator proceed normally. If
// "return", allow the original .return call to continue in the // context.method was "next", forget context.arg since it has been
// outer generator. // "consumed" by the delegate iterator. If context.method was
if (context.method !== "return") { // "return", allow the original .return call to continue in the
context.method = "next"; // outer generator.
context.arg = undefined; if (context.method !== "return") {
} context.method = "next";
context.arg = undefined;
} else { }
// Re-yield the result returned by the delegate method.
return info; } else {
} // Re-yield the result returned by the delegate method.
return info;
// The delegate iterator is finished, so forget it and continue with }
// the outer generator.
context.delegate = null; // The delegate iterator is finished, so forget it and continue with
return ContinueSentinel; // the outer generator.
} context.delegate = null;
return ContinueSentinel;
// Define Generator.prototype.{next,throw,return} in terms of the }
// unified ._invoke helper method.
defineIteratorMethods(Gp); // Define Generator.prototype.{next,throw,return} in terms of the
// unified ._invoke helper method.
Gp[toStringTagSymbol] = "Generator"; defineIteratorMethods(Gp);
// A Generator should always return itself as the iterator object when the Gp[toStringTagSymbol] = "Generator";
// @@iterator function is called on it. Some browsers' implementations of the
// iterator prototype chain incorrectly implement this, causing the Generator // A Generator should always return itself as the iterator object when the
// object to not be returned from this call. This ensures that doesn't happen. // @@iterator function is called on it. Some browsers' implementations of the
// See https://github.com/facebook/regenerator/issues/274 for more details. // iterator prototype chain incorrectly implement this, causing the Generator
Gp[iteratorSymbol] = function() { // object to not be returned from this call. This ensures that doesn't happen.
return this; // See https://github.com/facebook/regenerator/issues/274 for more details.
}; Gp[iteratorSymbol] = function () {
return this;
Gp.toString = function() { };
return "[object Generator]";
}; Gp.toString = function () {
return "[object Generator]";
function pushTryEntry(locs) { };
var entry = { tryLoc: locs[0] };
function pushTryEntry(locs) {
if (1 in locs) { var entry = { tryLoc: locs[0] };
entry.catchLoc = locs[1];
} if (1 in locs) {
entry.catchLoc = locs[1];
if (2 in locs) { }
entry.finallyLoc = locs[2];
entry.afterLoc = locs[3]; if (2 in locs) {
} entry.finallyLoc = locs[2];
entry.afterLoc = locs[3];
this.tryEntries.push(entry); }
}
this.tryEntries.push(entry);
function resetTryEntry(entry) { }
var record = entry.completion || {};
record.type = "normal"; function resetTryEntry(entry) {
delete record.arg; var record = entry.completion || {};
entry.completion = record; record.type = "normal";
} delete record.arg;
entry.completion = record;
function Context(tryLocsList) { }
// The root entry object (effectively a try statement without a catch
// or a finally block) gives us a place to store values thrown from function Context(tryLocsList) {
// locations where there is no enclosing try statement. // The root entry object (effectively a try statement without a catch
this.tryEntries = [{ tryLoc: "root" }]; // or a finally block) gives us a place to store values thrown from
tryLocsList.forEach(pushTryEntry, this); // locations where there is no enclosing try statement.
this.reset(true); this.tryEntries = [{ tryLoc: "root" }];
} tryLocsList.forEach(pushTryEntry, this);
this.reset(true);
runtime.keys = function(object) { }
var keys = [];
for (var key in object) { runtime.keys = function (object) {
keys.push(key); var keys = [];
} for (var key in object) {
keys.reverse(); keys.push(key);
}
// Rather than returning an object with a next method, we keep keys.reverse();
// things simple and return the next function itself.
return function next() { // Rather than returning an object with a next method, we keep
while (keys.length) { // things simple and return the next function itself.
var key = keys.pop(); return function next() {
if (key in object) { while (keys.length) {
next.value = key; var key = keys.pop();
next.done = false; if (key in object) {
return next; next.value = key;
} next.done = false;
} return next;
}
// To avoid creating an additional object, we just hang the .value }
// and .done properties off the next function object itself. This
// also ensures that the minifier will not anonymize the function. // To avoid creating an additional object, we just hang the .value
next.done = true; // and .done properties off the next function object itself. This
return next; // also ensures that the minifier will not anonymize the function.
}; next.done = true;
}; return next;
};
function values(iterable) { };
if (iterable) {
var iteratorMethod = iterable[iteratorSymbol]; function values(iterable) {
if (iteratorMethod) { if (iterable) {
return iteratorMethod.call(iterable); var iteratorMethod = iterable[iteratorSymbol];
} if (iteratorMethod) {
return iteratorMethod.call(iterable);
if (typeof iterable.next === "function") { }
return iterable;
} if (typeof iterable.next === "function") {
return iterable;
if (!isNaN(iterable.length)) { }
var i = -1, next = function next() {
while (++i < iterable.length) { if (!isNaN(iterable.length)) {
if (hasOwn.call(iterable, i)) { var i = -1, next = function next() {
next.value = iterable[i]; while (++i < iterable.length) {
next.done = false; if (hasOwn.call(iterable, i)) {
return next; next.value = iterable[i];
} next.done = false;
} return next;
}
next.value = undefined; }
next.done = true;
next.value = undefined;
return next; next.done = true;
};
return next;
return next.next = next; };
}
} return next.next = next;
}
// Return an iterator with no values. }
return { next: doneResult };
} // Return an iterator with no values.
runtime.values = values; return { next: doneResult };
}
function doneResult() { runtime.values = values;
return { value: undefined, done: true };
} function doneResult() {
return { value: undefined, done: true };
Context.prototype = { }
constructor: Context,
Context.prototype = {
reset: function(skipTempReset) { constructor: Context,
this.prev = 0;
this.next = 0; reset: function (skipTempReset) {
// Resetting context._sent for legacy support of Babel's this.prev = 0;
// function.sent implementation. this.next = 0;
this.sent = this._sent = undefined; // Resetting context._sent for legacy support of Babel's
this.done = false; // function.sent implementation.
this.delegate = null; this.sent = this._sent = undefined;
this.done = false;
this.method = "next"; this.delegate = null;
this.arg = undefined;
this.method = "next";
this.tryEntries.forEach(resetTryEntry); this.arg = undefined;
if (!skipTempReset) { this.tryEntries.forEach(resetTryEntry);
for (var name in this) {
// Not sure about the optimal order of these conditions: if (!skipTempReset) {
if (name.charAt(0) === "t" && for (var name in this) {
hasOwn.call(this, name) && // Not sure about the optimal order of these conditions:
!isNaN(+name.slice(1))) { if (name.charAt(0) === "t" &&
this[name] = undefined; hasOwn.call(this, name) &&
} !isNaN(+name.slice(1))) {
} this[name] = undefined;
} }
}, }
}
stop: function() { },
this.done = true;
stop: function () {
var rootEntry = this.tryEntries[0]; this.done = true;
var rootRecord = rootEntry.completion;
if (rootRecord.type === "throw") { var rootEntry = this.tryEntries[0];
throw rootRecord.arg; var rootRecord = rootEntry.completion;
} if (rootRecord.type === "throw") {
throw rootRecord.arg;
return this.rval; }
},
return this.rval;
dispatchException: function(exception) { },
if (this.done) {
throw exception; dispatchException: function (exception) {
} if (this.done) {
throw exception;
var context = this; }
function handle(loc, caught) {
record.type = "throw"; var context = this;
record.arg = exception; function handle(loc, caught) {
context.next = loc; record.type = "throw";
record.arg = exception;
if (caught) { context.next = loc;
// If the dispatched exception was caught by a catch block,
// then let that catch block handle the exception normally. if (caught) {
context.method = "next"; // If the dispatched exception was caught by a catch block,
context.arg = undefined; // then let that catch block handle the exception normally.
} context.method = "next";
context.arg = undefined;
return !! caught; }
}
return !!caught;
for (var i = this.tryEntries.length - 1; i >= 0; --i) { }
var entry = this.tryEntries[i];
var record = entry.completion; for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc === "root") { var record = entry.completion;
// Exception thrown outside of any try block that could handle
// it, so set the completion value of the entire function to if (entry.tryLoc === "root") {
// throw the exception. // Exception thrown outside of any try block that could handle
return handle("end"); // it, so set the completion value of the entire function to
} // throw the exception.
return handle("end");
if (entry.tryLoc <= this.prev) { }
var hasCatch = hasOwn.call(entry, "catchLoc");
var hasFinally = hasOwn.call(entry, "finallyLoc"); if (entry.tryLoc <= this.prev) {
var hasCatch = hasOwn.call(entry, "catchLoc");
if (hasCatch && hasFinally) { var hasFinally = hasOwn.call(entry, "finallyLoc");
if (this.prev < entry.catchLoc) {
return handle(entry.catchLoc, true); if (hasCatch && hasFinally) {
} else if (this.prev < entry.finallyLoc) { if (this.prev < entry.catchLoc) {
return handle(entry.finallyLoc); return handle(entry.catchLoc, true);
} } else if (this.prev < entry.finallyLoc) {
return handle(entry.finallyLoc);
} else if (hasCatch) { }
if (this.prev < entry.catchLoc) {
return handle(entry.catchLoc, true); } else if (hasCatch) {
} if (this.prev < entry.catchLoc) {
return handle(entry.catchLoc, true);
} else if (hasFinally) { }
if (this.prev < entry.finallyLoc) {
return handle(entry.finallyLoc); } else if (hasFinally) {
} if (this.prev < entry.finallyLoc) {
return handle(entry.finallyLoc);
} else { }
throw new Error("try statement without catch or finally");
} } else {
} throw new Error("try statement without catch or finally");
} }
}, }
}
abrupt: function(type, arg) { },
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i]; abrupt: function (type, arg) {
if (entry.tryLoc <= this.prev && for (var i = this.tryEntries.length - 1; i >= 0; --i) {
hasOwn.call(entry, "finallyLoc") && var entry = this.tryEntries[i];
this.prev < entry.finallyLoc) { if (entry.tryLoc <= this.prev &&
var finallyEntry = entry; hasOwn.call(entry, "finallyLoc") &&
break; this.prev < entry.finallyLoc) {
} var finallyEntry = entry;
} break;
}
if (finallyEntry && }
(type === "break" ||
type === "continue") && if (finallyEntry &&
finallyEntry.tryLoc <= arg && (type === "break" ||
arg <= finallyEntry.finallyLoc) { type === "continue") &&
// Ignore the finally entry if control is not jumping to a finallyEntry.tryLoc <= arg &&
// location outside the try/catch block. arg <= finallyEntry.finallyLoc) {
finallyEntry = null; // Ignore the finally entry if control is not jumping to a
} // location outside the try/catch block.
finallyEntry = null;
var record = finallyEntry ? finallyEntry.completion : {}; }
record.type = type;
record.arg = arg; var record = finallyEntry ? finallyEntry.completion : {};
record.type = type;
if (finallyEntry) { record.arg = arg;
this.method = "next";
this.next = finallyEntry.finallyLoc; if (finallyEntry) {
return ContinueSentinel; this.method = "next";
} this.next = finallyEntry.finallyLoc;
return ContinueSentinel;
return this.complete(record); }
},
return this.complete(record);
complete: function(record, afterLoc) { },
if (record.type === "throw") {
throw record.arg; complete: function (record, afterLoc) {
} if (record.type === "throw") {
throw record.arg;
if (record.type === "break" || }
record.type === "continue") {
this.next = record.arg; if (record.type === "break" ||
} else if (record.type === "return") { record.type === "continue") {
this.rval = this.arg = record.arg; this.next = record.arg;
this.method = "return"; } else if (record.type === "return") {
this.next = "end"; this.rval = this.arg = record.arg;
} else if (record.type === "normal" && afterLoc) { this.method = "return";
this.next = afterLoc; this.next = "end";
} } else if (record.type === "normal" && afterLoc) {
this.next = afterLoc;
return ContinueSentinel; }
},
return ContinueSentinel;
finish: function(finallyLoc) { },
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i]; finish: function (finallyLoc) {
if (entry.finallyLoc === finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) {
this.complete(entry.completion, entry.afterLoc); var entry = this.tryEntries[i];
resetTryEntry(entry); if (entry.finallyLoc === finallyLoc) {
return ContinueSentinel; this.complete(entry.completion, entry.afterLoc);
} resetTryEntry(entry);
} return ContinueSentinel;
}, }
}
"catch": function(tryLoc) { },
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i]; "catch": function (tryLoc) {
if (entry.tryLoc === tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var record = entry.completion; var entry = this.tryEntries[i];
if (record.type === "throw") { if (entry.tryLoc === tryLoc) {
var thrown = record.arg; var record = entry.completion;
resetTryEntry(entry); if (record.type === "throw") {
} var thrown = record.arg;
return thrown; resetTryEntry(entry);
} }
} return thrown;
}
// The context.catch method must only be called with a location }
// argument that corresponds to a known catch block.
throw new Error("illegal catch attempt"); // The context.catch method must only be called with a location
}, // argument that corresponds to a known catch block.
throw new Error("illegal catch attempt");
delegateYield: function(iterable, resultName, nextLoc) { },
this.delegate = {
iterator: values(iterable), delegateYield: function (iterable, resultName, nextLoc) {
resultName: resultName, this.delegate = {
nextLoc: nextLoc iterator: values(iterable),
}; resultName: resultName,
nextLoc: nextLoc
if (this.method === "next") { };
// Deliberately forget the last sent value so that we don't
// accidentally pass it on to the delegate. if (this.method === "next") {
this.arg = undefined; // Deliberately forget the last sent value so that we don't
} // accidentally pass it on to the delegate.
this.arg = undefined;
return ContinueSentinel; }
}
}; return ContinueSentinel;
}
};
})( })(
// In sloppy mode, unbound `this` refers to the global object, fallback to // In sloppy mode, unbound `this` refers to the global object, fallback to
// Function constructor if we're in global strict mode. That is sadly a form // Function constructor if we're in global strict mode. That is sadly a form
// of indirect eval which violates Content Security Policy. // of indirect eval which violates Content Security Policy.
(function() { return this })() || Function("return this")() (function () { return this })() || Function("return this")()
); );
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment