Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
E
ET04_hahaclass
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
ET04_hahaclass
Commits
bf4a369a
Commit
bf4a369a
authored
Aug 16, 2022
by
李维
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
修复一体机拖拽问题
parent
48584064
Changes
4
Hide whitespace changes
Inline
Side-by-side
Showing
4 changed files
with
738 additions
and
26 deletions
+738
-26
runtime.js
assets/ET04_hahaclass/script/runtime.js
+729
-0
runtime.js.meta
assets/ET04_hahaclass/script/runtime.js.meta
+9
-0
textures的副本.meta
assets/ET04_hahaclass/textures的副本.meta
+0
-13
option.meta
assets/ET04_hahaclass/textures的副本/option.meta
+0
-13
No files found.
assets/ET04_hahaclass/script/runtime.js
0 → 100644
View file @
bf4a369a
/**
* Copyright (c) 2014-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
cc
.
sys
.
capabilities
[
"
touches
"
]
=
true
;
!
(
function
(
global
)
{
"
use strict
"
;
var
Op
=
Object
.
prototype
;
var
hasOwn
=
Op
.
hasOwnProperty
;
var
undefined
;
// More compressible than void 0.
var
$Symbol
=
typeof
Symbol
===
"
function
"
?
Symbol
:
{};
var
iteratorSymbol
=
$Symbol
.
iterator
||
"
@@iterator
"
;
var
asyncIteratorSymbol
=
$Symbol
.
asyncIterator
||
"
@@asyncIterator
"
;
var
toStringTagSymbol
=
$Symbol
.
toStringTag
||
"
@@toStringTag
"
;
var
inModule
=
typeof
module
===
"
object
"
;
var
runtime
=
global
.
regeneratorRuntime
;
if
(
runtime
)
{
if
(
inModule
)
{
// If regeneratorRuntime is defined globally and we're in a module,
// make the exports object identical to regeneratorRuntime.
module
.
exports
=
runtime
;
}
// 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
:
{};
function
wrap
(
innerFn
,
outerFn
,
self
,
tryLocsList
)
{
// If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
var
protoGenerator
=
outerFn
&&
outerFn
.
prototype
instanceof
Generator
?
outerFn
:
Generator
;
var
generator
=
Object
.
create
(
protoGenerator
.
prototype
);
var
context
=
new
Context
(
tryLocsList
||
[]);
// The ._invoke method unifies the implementations of the .next,
// .throw, and .return methods.
generator
.
_invoke
=
makeInvokeMethod
(
innerFn
,
self
,
context
);
return
generator
;
}
runtime
.
wrap
=
wrap
;
// Try/catch helper to minimize deoptimizations. Returns a completion
// record like context.tryEntries[i].completion. This interface could
// have been (and was previously) designed to take a closure to be
// invoked without arguments, but in all the cases we care about we
// already have an existing method we want to call, so there's no need
// to create a new function object. We can even get away with assuming
// the method takes exactly one argument, since that happens to be true
// in every case, so we don't have to touch the arguments object. The
// only additional allocation required is the completion record, which
// has a stable shape and so hopefully should be cheap to allocate.
function
tryCatch
(
fn
,
obj
,
arg
)
{
try
{
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
GenStateCompleted
=
"
completed
"
;
// Returning this object from the innerFn has the same effect as
// breaking out of the dispatch switch statement.
var
ContinueSentinel
=
{};
// Dummy constructor functions that we use as the .constructor and
// .constructor.prototype properties for functions that return Generator
// objects. For full spec compliance, you may wish to configure your
// minifier not to mangle the names of these two functions.
function
Generator
()
{
}
function
GeneratorFunction
()
{
}
function
GeneratorFunctionPrototype
()
{
}
// This is a polyfill for %IteratorPrototype% for environments that
// don't natively support it.
var
IteratorPrototype
=
{};
IteratorPrototype
[
iteratorSymbol
]
=
function
()
{
return
this
;
};
var
getProto
=
Object
.
getPrototypeOf
;
var
NativeIteratorPrototype
=
getProto
&&
getProto
(
getProto
(
values
([])));
if
(
NativeIteratorPrototype
&&
NativeIteratorPrototype
!==
Op
&&
hasOwn
.
call
(
NativeIteratorPrototype
,
iteratorSymbol
))
{
// 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
;
GeneratorFunctionPrototype
.
constructor
=
GeneratorFunction
;
GeneratorFunctionPrototype
[
toStringTagSymbol
]
=
GeneratorFunction
.
displayName
=
"
GeneratorFunction
"
;
// Helper for defining the .next, .throw, and .return methods of the
// Iterator interface in terms of a single ._invoke method.
function
defineIteratorMethods
(
prototype
)
{
[
"
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
?
ctor
===
GeneratorFunction
||
// For the native GeneratorFunction constructor, the best we can
// do is to check its .name property.
(
ctor
.
displayName
||
ctor
.
name
)
===
"
GeneratorFunction
"
:
false
;
};
runtime
.
mark
=
function
(
genFun
)
{
if
(
Object
.
setPrototypeOf
)
{
Object
.
setPrototypeOf
(
genFun
,
GeneratorFunctionPrototype
);
}
else
{
genFun
.
__proto__
=
GeneratorFunctionPrototype
;
if
(
!
(
toStringTagSymbol
in
genFun
))
{
genFun
[
toStringTagSymbol
]
=
"
GeneratorFunction
"
;
}
}
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
// 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
);
if
(
record
.
type
===
"
throw
"
)
{
reject
(
record
.
arg
);
}
else
{
var
result
=
record
.
arg
;
var
value
=
result
.
value
;
if
(
value
&&
typeof
value
===
"
object
"
&&
hasOwn
.
call
(
value
,
"
__await
"
))
{
return
Promise
.
resolve
(
value
.
__await
).
then
(
function
(
value
)
{
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
// current iteration. If the Promise is rejected, however, the
// result for this iteration will be rejected with the same
// reason. Note that rejections of yielded Promises are not
// thrown back into the generator function, as is the case
// when an awaited Promise is rejected. This difference in
// behavior between yield and await is important, because it
// allows the consumer to decide what to do with the yielded
// rejection (swallow it and continue, manually .throw it back
// into the generator, abandon iteration, whatever). With
// await, by contrast, there is no opportunity to examine the
// rejection reason outside the generator function, so the
// only option is to throw it from the await expression, and
// let the generator function handle the exception.
result
.
value
=
unwrapped
;
resolve
(
result
);
},
reject
);
}
}
var
previousPromise
;
function
enqueue
(
method
,
arg
)
{
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,
// so that results are always delivered in the correct order. If
// enqueue has not been called before, then it is important to
// call invoke immediately, without waiting on a callback to fire,
// so that the async generator function has the opportunity to do
// any necessary setup in a predictable way. This predictability
// is why the Promise constructor synchronously invokes its
// executor callback, and why async functions synchronously
// execute code before the first await. Since we implement simple
// async functions in terms of async generators, it is especially
// important to get this right, even though it requires care.
previousPromise
?
previousPromise
.
then
(
callInvokeWithMethodAndArg
,
// Avoid propagating failures to Promises returned by later
// 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
;
}
defineIteratorMethods
(
AsyncIterator
.
prototype
);
AsyncIterator
.
prototype
[
asyncIteratorSymbol
]
=
function
()
{
return
this
;
};
runtime
.
AsyncIterator
=
AsyncIterator
;
// Note that simple async functions are implemented on top of
// AsyncIterator objects; they just return a Promise for the value of
// the final result produced by the iterator.
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
result
.
done
?
result
.
value
:
iter
.
next
();
});
};
function
makeInvokeMethod
(
innerFn
,
self
,
context
)
{
var
state
=
GenStateSuspendedStart
;
return
function
invoke
(
method
,
arg
)
{
if
(
state
===
GenStateExecuting
)
{
throw
new
Error
(
"
Generator is already running
"
);
}
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
();
}
context
.
method
=
method
;
context
.
arg
=
arg
;
while
(
true
)
{
var
delegate
=
context
.
delegate
;
if
(
delegate
)
{
var
delegateResult
=
maybeInvokeDelegate
(
delegate
,
context
);
if
(
delegateResult
)
{
if
(
delegateResult
===
ContinueSentinel
)
continue
;
return
delegateResult
;
}
}
if
(
context
.
method
===
"
next
"
)
{
// Setting context._sent for legacy support of Babel's
// function.sent implementation.
context
.
sent
=
context
.
_sent
=
context
.
arg
;
}
else
if
(
context
.
method
===
"
throw
"
)
{
if
(
state
===
GenStateSuspendedStart
)
{
state
=
GenStateCompleted
;
throw
context
.
arg
;
}
context
.
dispatchException
(
context
.
arg
);
}
else
if
(
context
.
method
===
"
return
"
)
{
context
.
abrupt
(
"
return
"
,
context
.
arg
);
}
state
=
GenStateExecuting
;
var
record
=
tryCatch
(
innerFn
,
self
,
context
);
if
(
record
.
type
===
"
normal
"
)
{
// If an exception is thrown from innerFn, we leave state ===
// GenStateExecuting and loop back for another invocation.
state
=
context
.
done
?
GenStateCompleted
:
GenStateSuspendedYield
;
if
(
record
.
arg
===
ContinueSentinel
)
{
continue
;
}
return
{
value
:
record
.
arg
,
done
:
context
.
done
};
}
else
if
(
record
.
type
===
"
throw
"
)
{
state
=
GenStateCompleted
;
// Dispatch the exception by looping back around to the
// 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,
// setting context.delegate to null, and returning the ContinueSentinel.
function
maybeInvokeDelegate
(
delegate
,
context
)
{
var
method
=
delegate
.
iterator
[
context
.
method
];
if
(
method
===
undefined
)
{
// A .throw or .return when the delegate iterator has no .throw
// method always terminates the yield* loop.
context
.
delegate
=
null
;
if
(
context
.
method
===
"
throw
"
)
{
if
(
delegate
.
iterator
.
return
)
{
// If the delegate iterator has a return method, give it a
// chance to clean up.
context
.
method
=
"
return
"
;
context
.
arg
=
undefined
;
maybeInvokeDelegate
(
delegate
,
context
);
if
(
context
.
method
===
"
throw
"
)
{
// 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
"
);
}
return
ContinueSentinel
;
}
var
record
=
tryCatch
(
method
,
delegate
.
iterator
,
context
.
arg
);
if
(
record
.
type
===
"
throw
"
)
{
context
.
method
=
"
throw
"
;
context
.
arg
=
record
.
arg
;
context
.
delegate
=
null
;
return
ContinueSentinel
;
}
var
info
=
record
.
arg
;
if
(
!
info
)
{
context
.
method
=
"
throw
"
;
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).
context
[
delegate
.
resultName
]
=
info
.
value
;
// Resume execution at the desired location (see delegateYield).
context
.
next
=
delegate
.
nextLoc
;
// If context.method was "throw" but the delegate handled the
// exception, let the outer generator proceed normally. If
// context.method was "next", forget context.arg since it has been
// "consumed" by the delegate iterator. If context.method was
// "return", allow the original .return call to continue in the
// outer generator.
if
(
context
.
method
!==
"
return
"
)
{
context
.
method
=
"
next
"
;
context
.
arg
=
undefined
;
}
}
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
;
return
ContinueSentinel
;
}
// Define Generator.prototype.{next,throw,return} in terms of the
// unified ._invoke helper method.
defineIteratorMethods
(
Gp
);
Gp
[
toStringTagSymbol
]
=
"
Generator
"
;
// A Generator should always return itself as the iterator object when the
// @@iterator function is called on it. Some browsers' implementations of the
// iterator prototype chain incorrectly implement this, causing the Generator
// object to not be returned from this call. This ensures that doesn't happen.
// See https://github.com/facebook/regenerator/issues/274 for more details.
Gp
[
iteratorSymbol
]
=
function
()
{
return
this
;
};
Gp
.
toString
=
function
()
{
return
"
[object Generator]
"
;
};
function
pushTryEntry
(
locs
)
{
var
entry
=
{
tryLoc
:
locs
[
0
]
};
if
(
1
in
locs
)
{
entry
.
catchLoc
=
locs
[
1
];
}
if
(
2
in
locs
)
{
entry
.
finallyLoc
=
locs
[
2
];
entry
.
afterLoc
=
locs
[
3
];
}
this
.
tryEntries
.
push
(
entry
);
}
function
resetTryEntry
(
entry
)
{
var
record
=
entry
.
completion
||
{};
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
// locations where there is no enclosing try statement.
this
.
tryEntries
=
[{
tryLoc
:
"
root
"
}];
tryLocsList
.
forEach
(
pushTryEntry
,
this
);
this
.
reset
(
true
);
}
runtime
.
keys
=
function
(
object
)
{
var
keys
=
[];
for
(
var
key
in
object
)
{
keys
.
push
(
key
);
}
keys
.
reverse
();
// Rather than returning an object with a next method, we keep
// things simple and return the next function itself.
return
function
next
()
{
while
(
keys
.
length
)
{
var
key
=
keys
.
pop
();
if
(
key
in
object
)
{
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.
next
.
done
=
true
;
return
next
;
};
};
function
values
(
iterable
)
{
if
(
iterable
)
{
var
iteratorMethod
=
iterable
[
iteratorSymbol
];
if
(
iteratorMethod
)
{
return
iteratorMethod
.
call
(
iterable
);
}
if
(
typeof
iterable
.
next
===
"
function
"
)
{
return
iterable
;
}
if
(
!
isNaN
(
iterable
.
length
))
{
var
i
=
-
1
,
next
=
function
next
()
{
while
(
++
i
<
iterable
.
length
)
{
if
(
hasOwn
.
call
(
iterable
,
i
))
{
next
.
value
=
iterable
[
i
];
next
.
done
=
false
;
return
next
;
}
}
next
.
value
=
undefined
;
next
.
done
=
true
;
return
next
;
};
return
next
.
next
=
next
;
}
}
// Return an iterator with no values.
return
{
next
:
doneResult
};
}
runtime
.
values
=
values
;
function
doneResult
()
{
return
{
value
:
undefined
,
done
:
true
};
}
Context
.
prototype
=
{
constructor
:
Context
,
reset
:
function
(
skipTempReset
)
{
this
.
prev
=
0
;
this
.
next
=
0
;
// Resetting context._sent for legacy support of Babel's
// function.sent implementation.
this
.
sent
=
this
.
_sent
=
undefined
;
this
.
done
=
false
;
this
.
delegate
=
null
;
this
.
method
=
"
next
"
;
this
.
arg
=
undefined
;
this
.
tryEntries
.
forEach
(
resetTryEntry
);
if
(
!
skipTempReset
)
{
for
(
var
name
in
this
)
{
// Not sure about the optimal order of these conditions:
if
(
name
.
charAt
(
0
)
===
"
t
"
&&
hasOwn
.
call
(
this
,
name
)
&&
!
isNaN
(
+
name
.
slice
(
1
)))
{
this
[
name
]
=
undefined
;
}
}
}
},
stop
:
function
()
{
this
.
done
=
true
;
var
rootEntry
=
this
.
tryEntries
[
0
];
var
rootRecord
=
rootEntry
.
completion
;
if
(
rootRecord
.
type
===
"
throw
"
)
{
throw
rootRecord
.
arg
;
}
return
this
.
rval
;
},
dispatchException
:
function
(
exception
)
{
if
(
this
.
done
)
{
throw
exception
;
}
var
context
=
this
;
function
handle
(
loc
,
caught
)
{
record
.
type
=
"
throw
"
;
record
.
arg
=
exception
;
context
.
next
=
loc
;
if
(
caught
)
{
// If the dispatched exception was caught by a catch block,
// then let that catch block handle the exception normally.
context
.
method
=
"
next
"
;
context
.
arg
=
undefined
;
}
return
!!
caught
;
}
for
(
var
i
=
this
.
tryEntries
.
length
-
1
;
i
>=
0
;
--
i
)
{
var
entry
=
this
.
tryEntries
[
i
];
var
record
=
entry
.
completion
;
if
(
entry
.
tryLoc
===
"
root
"
)
{
// Exception thrown outside of any try block that could handle
// 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
(
hasCatch
&&
hasFinally
)
{
if
(
this
.
prev
<
entry
.
catchLoc
)
{
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
(
hasFinally
)
{
if
(
this
.
prev
<
entry
.
finallyLoc
)
{
return
handle
(
entry
.
finallyLoc
);
}
}
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
];
if
(
entry
.
tryLoc
<=
this
.
prev
&&
hasOwn
.
call
(
entry
,
"
finallyLoc
"
)
&&
this
.
prev
<
entry
.
finallyLoc
)
{
var
finallyEntry
=
entry
;
break
;
}
}
if
(
finallyEntry
&&
(
type
===
"
break
"
||
type
===
"
continue
"
)
&&
finallyEntry
.
tryLoc
<=
arg
&&
arg
<=
finallyEntry
.
finallyLoc
)
{
// 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
;
if
(
finallyEntry
)
{
this
.
method
=
"
next
"
;
this
.
next
=
finallyEntry
.
finallyLoc
;
return
ContinueSentinel
;
}
return
this
.
complete
(
record
);
},
complete
:
function
(
record
,
afterLoc
)
{
if
(
record
.
type
===
"
throw
"
)
{
throw
record
.
arg
;
}
if
(
record
.
type
===
"
break
"
||
record
.
type
===
"
continue
"
)
{
this
.
next
=
record
.
arg
;
}
else
if
(
record
.
type
===
"
return
"
)
{
this
.
rval
=
this
.
arg
=
record
.
arg
;
this
.
method
=
"
return
"
;
this
.
next
=
"
end
"
;
}
else
if
(
record
.
type
===
"
normal
"
&&
afterLoc
)
{
this
.
next
=
afterLoc
;
}
return
ContinueSentinel
;
},
finish
:
function
(
finallyLoc
)
{
for
(
var
i
=
this
.
tryEntries
.
length
-
1
;
i
>=
0
;
--
i
)
{
var
entry
=
this
.
tryEntries
[
i
];
if
(
entry
.
finallyLoc
===
finallyLoc
)
{
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
];
if
(
entry
.
tryLoc
===
tryLoc
)
{
var
record
=
entry
.
completion
;
if
(
record
.
type
===
"
throw
"
)
{
var
thrown
=
record
.
arg
;
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
"
);
},
delegateYield
:
function
(
iterable
,
resultName
,
nextLoc
)
{
this
.
delegate
=
{
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.
this
.
arg
=
undefined
;
}
return
ContinueSentinel
;
}
};
})(
// 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
// of indirect eval which violates Content Security Policy.
(
function
()
{
return
this
})()
||
Function
(
"
return this
"
)()
);
assets/ET04_hahaclass/script/runtime.js.meta
0 → 100644
View file @
bf4a369a
{
"ver": "1.0.8",
"uuid": "929802f2-389e-4b6f-9f0b-8b43fcd0e839",
"isPlugin": true,
"loadPluginInWeb": true,
"loadPluginInNative": true,
"loadPluginInEditor": false,
"subMetas": {}
}
\ No newline at end of file
assets/ET04_hahaclass/textures的副本.meta
deleted
100644 → 0
View file @
48584064
{
"ver": "1.1.2",
"uuid": "14fad522-d449-45d9-9a76-8fd0f5bd60df",
"isBundle": false,
"bundleName": "",
"priority": 1,
"compressionType": {},
"optimizeHotUpdate": {},
"inlineSpriteFrames": {},
"isRemoteBundle": {},
"subMetas": {}
}
\ No newline at end of file
assets/ET04_hahaclass/textures的副本/option.meta
deleted
100644 → 0
View file @
48584064
{
"ver": "1.1.2",
"uuid": "607805bf-3b7e-4de6-bce5-7a8df6fd9a31",
"isBundle": false,
"bundleName": "",
"priority": 1,
"compressionType": {},
"optimizeHotUpdate": {},
"inlineSpriteFrames": {},
"isRemoteBundle": {},
"subMetas": {}
}
\ No newline at end of file
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