Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
E
ET26
Project
Project
Details
Activity
Releases
Cycle Analytics
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Charts
Issues
0
Issues
0
List
Boards
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Charts
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Charts
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
template admin
ET26
Commits
f14d0421
Commit
f14d0421
authored
Oct 28, 2021
by
Lwd
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
commit
parent
a9489a3b
Changes
2
Hide whitespace changes
Inline
Side-by-side
Showing
2 changed files
with
723 additions
and
718 deletions
+723
-718
view.js
play/assets/ET26/script/common/view.js
+3
-0
runtime.js
play/assets/ET26/script/game/runtime.js
+720
-718
No files found.
play/assets/ET26/script/common/view.js
View file @
f14d0421
...
@@ -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
)
{
...
...
play/assets/ET26/script/game/runtime.js
View file @
f14d0421
...
@@ -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
"
)()
);
);
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment