`Any` is a type that is compatible with any other in both ways.
This means that a value of any type can be assigned to `Any`, and
vice-versa, a value of `Any` type can be assigned to any other type.
It's a more type-safe alternative to `Dynamic`, because it doesn't
support field access or operators and it's bound to monomorphs. So,
to work with the actual value, it needs to be explicitly promoted
to another type.
<__promote params="T" get="inline" set="null" line="37" static="1">
<__promote params="T" get="inline" set="null" line="37" static="1">
The length of `this` Array.Returns a new Array by appending the elements of `a` to the elements of
`this` Array.
This operation does not modify `this` Array.
If `a` is the empty Array `[]`, a copy of `this` Array is returned.
The length of the returned Array is equal to the sum of `this.length`
and `a.length`.
If `a` is `null`, the result is unspecified.Returns a string representation of `this` Array, with `sep` separating
each element.
The result of this operation is equal to `Std.string(this[0]) + sep +
Std.string(this[1]) + sep + ... + sep + Std.string(this[this.length-1])`
If `this` is the empty Array `[]`, the result is the empty String `""`.
If `this` has exactly one element, the result is equal to a call to
`Std.string(this[0])`.
If `sep` is null, the result is unspecified.Removes the last element of `this` Array and returns it.
This operation modifies `this` Array in place.
If `this` has at least one element, `this.length` will decrease by 1.
If `this` is the empty Array `[]`, null is returned and the length
remains 0.Adds the element `x` at the end of `this` Array and returns the new
length of `this` Array.
This operation modifies `this` Array in place.
`this.length` increases by 1.Removes the first element of `this` Array and returns it.
This operation modifies `this` Array in place.
If `this` has at least one element, `this`.length and the index of each
remaining element is decreased by 1.
If `this` is the empty Array `[]`, `null` is returned and the length
remains 0.Creates a shallow copy of the range of `this` Array, starting at and
including `pos`, up to but not including `end`.
This operation does not modify `this` Array.
The elements are not copied and retain their identity.
If `end` is omitted or exceeds `this.length`, it defaults to the end of
`this` Array.
If `pos` or `end` are negative, their offsets are calculated from the
end of `this` Array by `this.length + pos` and `this.length + end`
respectively. If this yields a negative value, 0 is used instead.
If `pos` exceeds `this.length` or if `end` is less than or equals
`pos`, the result is `[]`. y and a
negative Int if x < y.
This operation modifies `this` Array in place.
The sort operation is not guaranteed to be stable, which means that the
order of equal elements may not be retained. For a stable Array sorting
algorithm, `haxe.ds.ArraySort.sort()` can be used instead.
If `f` is null, the result is unspecified.]]>Returns a string representation of `this` Array.
The result will include the individual elements' String representations
separated by comma. The enclosing [ ] may be missing on some platforms,
use `Std.string()` to get a String representation that is consistent
across platforms.Adds the element `x` at the start of `this` Array.
This operation modifies `this` Array in place.
`this.length` and the index of each Array element increases by 1.Inserts the element `x` at the position `pos`.
This operation modifies `this` Array in place.
The offset is calculated like so:
- If `pos` exceeds `this.length`, the offset is `this.length`.
- If `pos` is negative, the offset is calculated from the end of `this`
Array, i.e. `this.length + pos`. If this yields a negative value, the
offset is 0.
- Otherwise, the offset is `pos`.
If the resulting offset does not exceed `this.length`, all elements from
and including that offset to the end of `this` Array are moved one index
ahead.Removes the first occurrence of `x` in `this` Array.
This operation modifies `this` Array in place.
If `x` is found by checking standard equality, it is removed from `this`
Array and all following elements are reindexed accordingly. The function
then returns true.
If `x` is not found, `this` Array is not changed and the function
returns false.Returns whether `this` Array contains `x`.
If `x` is found by checking standard equality, the function returns `true`, otherwise
the function returns `false`.Returns position of the first occurrence of `x` in `this` Array, searching front to back.
If `x` is found by checking standard equality, the function returns its index.
If `x` is not found, the function returns -1.
If `fromIndex` is specified, it will be used as the starting index to search from,
otherwise search starts with zero index. If it is negative, it will be taken as the
offset from the end of `this` Array to compute the starting index. If given or computed
starting index is less than 0, the whole array will be searched, if it is greater than
or equal to the length of `this` Array, the function returns -1.Returns position of the last occurrence of `x` in `this` Array, searching back to front.
If `x` is found by checking standard equality, the function returns its index.
If `x` is not found, the function returns -1.
If `fromIndex` is specified, it will be used as the starting index to search from,
otherwise search starts with the last element index. If it is negative, it will be
taken as the offset from the end of `this` Array to compute the starting index. If
given or computed starting index is greater than or equal to the length of `this` Array,
the whole array will be searched, if it is less than 0, the function returns -1.Returns a shallow copy of `this` Array.
The elements are not copied and retain their identity, so
`a[i] == a.copy()[i]` is true for any valid `i`. However,
`a == a.copy()` is always false.Returns an iterator of the Array values.Returns an iterator of the Array indices and values.Returns an Array containing those elements of `this` for which `f`
returned true.
The individual elements are not duplicated and retain their identity.
If `f` is null, the result is unspecified.Set the length of the Array.
If `len` is shorter than the array's current size, the last
`length - len` elements will be removed. If `len` is longer, the Array
will be extended, with new elements set to a target-specific default
value:
- always null on dynamic targets
- 0, 0.0 or false for Int, Float and Bool respectively on static targets
- null for other types on static targetsCreates a new Array.An Array is a storage for values. You can access it using indexes or
with its API.
@see https://haxe.org/manual/std-Array.html
@see https://haxe.org/manual/lf-array-comprehension.htmlAn abstract type that represents a Class.
See `Type` for the Haxe Reflection API.
@see https://haxe.org/manual/types-class-instance.htmlReturns a Date representing the current local time.Creates a Date from the timestamp (in milliseconds) `t`.Creates a Date from the formatted string `s`. The following formats are
accepted by the function:
- `"YYYY-MM-DD hh:mm:ss"`
- `"YYYY-MM-DD"`
- `"hh:mm:ss"`
The first two formats expressed a date in local time. The third is a time
relative to the UTC epoch.Returns the timestamp (in milliseconds) of `this` date.
On cpp and neko, this function only has a second resolution, so the
result will always be a multiple of `1000.0`, e.g. `1454698271000.0`.
To obtain the current timestamp with better precision on cpp and neko,
see the `Sys.time` API.
For measuring time differences with millisecond accuracy on
all platforms, see `haxe.Timer.stamp`.Returns the hours of `this` Date (0-23 range) in the local timezone.Returns the minutes of `this` Date (0-59 range) in the local timezone.Returns the seconds of `this` Date (0-59 range) in the local timezone.Returns the full year of `this` Date (4 digits) in the local timezone.Returns the month of `this` Date (0-11 range) in the local timezone.
Note that the month number is zero-based.Returns the day of `this` Date (1-31 range) in the local timezone.Returns the day of the week of `this` Date (0-6 range, where `0` is Sunday)
in the local timezone.Returns the hours of `this` Date (0-23 range) in UTC.Returns the minutes of `this` Date (0-59 range) in UTC.Returns the seconds of `this` Date (0-59 range) in UTC.Returns the full year of `this` Date (4 digits) in UTC.Returns the month of `this` Date (0-11 range) in UTC.
Note that the month number is zero-based.Returns the day of `this` Date (1-31 range) in UTC.Returns the day of the week of `this` Date (0-6 range, where `0` is Sunday)
in UTC.Returns the time zone difference of `this` Date in the current locale
to UTC, in minutes.
Assuming the function is executed on a machine in a UTC+2 timezone,
`Date.now().getTimezoneOffset()` will return `-120`.Returns a string representation of `this` Date in the local timezone
using the standard format `YYYY-MM-DD HH:MM:SS`. See `DateTools.format` for
other formatting rules.Creates a new date object from the given arguments.
The behaviour of a Date instance is only consistent across platforms if
the the arguments describe a valid date.
- month: 0 to 11 (note that this is zero-based)
- day: 1 to 31
- hour: 0 to 23
- min: 0 to 59
- sec: 0 to 59The Date class provides a basic structure for date and time related
information. Date instances can be created by
- `new Date()` for a specific date,
- `Date.now()` to obtain information about the current time,
- `Date.fromTime()` with a given timestamp or
- `Date.fromString()` by parsing from a String.
There are some extra functions available in the `DateTools` class.
In the context of Haxe dates, a timestamp is defined as the number of
milliseconds elapsed since 1st January 1970 UTC.
## Supported range
Due to platform limitations, only dates in the range 1970 through 2038 are
supported consistently. Some targets may support dates outside this range,
depending on the OS at runtime. The `Date.fromTime` method will not work with
timestamps outside the range on any target."http://adobe.com/AS3/2006/builtin""http://adobe.com/AS3/2006/builtin""RegExp"An abstract type that represents an Enum type.
The corresponding enum instance type is `EnumValue`.
See `Type` for the Haxe Reflection API.
@see https://haxe.org/manual/types-enum-instance.htmlAn abstract type that represents any enum value.
See `Type` for the Haxe Reflection API.
@see https://haxe.org/manual/types-enum-instance.htmlRepresents the ratio of the circumference of a circle to its diameter,
specified by the constant, π. `PI` is approximately `3.141592653589793`.A special `Float` constant which denotes negative infinity.
For example, this is the result of `-1.0 / 0.0`.
Operations with `NEGATIVE_INFINITY` as an operand may result in
`NEGATIVE_INFINITY`, `POSITIVE_INFINITY` or `NaN`.
If this constant is converted to an `Int`, e.g. through `Std.int()`, the
result is unspecified.A special `Float` constant which denotes positive infinity.
For example, this is the result of `1.0 / 0.0`.
Operations with `POSITIVE_INFINITY` as an operand may result in
`NEGATIVE_INFINITY`, `POSITIVE_INFINITY` or `NaN`.
If this constant is converted to an `Int`, e.g. through `Std.int()`, the
result is unspecified.A special `Float` constant which denotes an invalid number.
`NaN` stands for "Not a Number". It occurs when a mathematically incorrect
operation is executed, such as taking the square root of a negative
number: `Math.sqrt(-1)`.
All further operations with `NaN` as an operand will result in `NaN`.
If this constant is converted to an `Int`, e.g. through `Std.int()`, the
result is unspecified.
In order to test if a value is `NaN`, you should use `Math.isNaN()` function.Returns the absolute value of `v`.
- If `v` is positive or `0`, the result is unchanged. Otherwise the result is `-v`.
- If `v` is `NEGATIVE_INFINITY` or `POSITIVE_INFINITY`, the result is `POSITIVE_INFINITY`.
- If `v` is `NaN`, the result is `NaN`.Returns the smaller of values `a` and `b`.
- If `a` or `b` are `NaN`, the result is `NaN`.
- If `a` or `b` are `NEGATIVE_INFINITY`, the result is `NEGATIVE_INFINITY`.
- If `a` and `b` are `POSITIVE_INFINITY`, the result is `POSITIVE_INFINITY`.Returns the greater of values `a` and `b`.
- If `a` or `b` are `NaN`, the result is `NaN`.
- If `a` or `b` are `POSITIVE_INFINITY`, the result is `POSITIVE_INFINITY`.
- If `a` and `b` are `NEGATIVE_INFINITY`, the result is `NEGATIVE_INFINITY`.Returns the trigonometric sine of the specified angle `v`, in radians.
If `v` is `NaN` or infinite, the result is `NaN`.Returns the trigonometric cosine of the specified angle `v`, in radians.
If `v` is `NaN` or infinite, the result is `NaN`.Returns the trigonometric tangent of the specified angle `v`, in radians.
If `v` is `NaN` or infinite, the result is `NaN`.Returns the trigonometric arc of the specified angle `v`, in radians.
If `v` is `NaN` or infinite, the result is `NaN`.Returns the trigonometric arc cosine of the specified angle `v`,
in radians.
If `v` is `NaN` or infinite, the result is `NaN`.Returns the trigonometric arc tangent of the specified angle `v`,
in radians.
If `v` is `NaN` or infinite, the result is `NaN`.Returns the trigonometric arc tangent whose tangent is the quotient of
two specified numbers, in radians.
If parameter `x` or `y` is `NaN`, `NEGATIVE_INFINITY` or `POSITIVE_INFINITY`,
the result is `NaN`.Returns Euler's number, raised to the power of `v`.
`exp(1.0)` is approximately `2.718281828459`.
- If `v` is `POSITIVE_INFINITY`, the result is `POSITIVE_INFINITY`.
- If `v` is `NEGATIVE_INFINITY`, the result is `0.0`.
- If `v` is `NaN`, the result is `NaN`.Returns the natural logarithm of `v`.
This is the mathematical inverse operation of exp,
i.e. `log(exp(v)) == v` always holds.
- If `v` is negative (including `NEGATIVE_INFINITY`) or `NaN`, the result is `NaN`.
- If `v` is `POSITIVE_INFINITY`, the result is `POSITIVE_INFINITY`.
- If `v` is `0.0`, the result is `NEGATIVE_INFINITY`.Returns a specified base `v` raised to the specified power `exp`.Returns the square root of `v`.
- If `v` is negative (including `NEGATIVE_INFINITY`) or `NaN`, the result is `NaN`.
- If `v` is `POSITIVE_INFINITY`, the result is `POSITIVE_INFINITY`.
- If `v` is `0.0`, the result is `0.0`.Rounds `v` to the nearest integer value.
Ties are rounded up, so that `0.5` becomes `1` and `-0.5` becomes `0`.
If `v` is outside of the signed `Int32` range, or is `NaN`, `NEGATIVE_INFINITY`
or `POSITIVE_INFINITY`, the result is unspecified.Returns the largest integer value that is not greater than `v`.
If `v` is outside of the signed `Int32` range, or is `NaN`, `NEGATIVE_INFINITY`
or `POSITIVE_INFINITY`, the result is unspecified.Returns the smallest integer value that is not less than `v`.
If `v` is outside of the signed `Int32` range, or is `NaN`, `NEGATIVE_INFINITY`
or `POSITIVE_INFINITY`, the result is unspecified.Returns a pseudo-random number which is greater than or equal to `0.0`,
and less than `1.0`.Returns the largest integer value that is not greater than `v`, as a `Float`.
If `v` is is `NaN`, `NEGATIVE_INFINITY` or `POSITIVE_INFINITY`,
the result is unspecified.Returns the smallest integer value that is not less than `v`, as a `Float`.
If `v` is is `NaN`, `NEGATIVE_INFINITY` or `POSITIVE_INFINITY`,
the result is unspecified.Rounds `v` to the nearest integer value, as a Float.
Ties are rounded up, so that `0.5` becomes `1` and `-0.5` becomes `0`.
If `v` is is `NaN`, `NEGATIVE_INFINITY` or `POSITIVE_INFINITY`,
the result is unspecified.Tells if `f` is a finite number.
If `f` is `POSITIVE_INFINITY`, `NEGATIVE_INFINITY` or `NaN`, the result
is `false`, otherwise the result is `true`.Tells if `f` is `Math.NaN`.
If `f` is `NaN`, the result is `true`, otherwise the result is `false`.
In particular, `null`, `POSITIVE_INFINITY` and `NEGATIVE_INFINITY` are
not considered `NaN`.This class defines mathematical functions and constants.
@see https://haxe.org/manual/std-math.htmlTells if structure `o` has a field named `field`.
This is only guaranteed to work for anonymous structures. Refer to
`Type.getInstanceFields` for a function supporting class instances.
If `o` or `field` are null, the result is unspecified.Returns the value of the field named `field` on object `o`.
If `o` is not an object or has no field named `field`, the result is
null.
If the field is defined as a property, its accessors are ignored. Refer
to `Reflect.getProperty` for a function supporting property accessors.
If `field` is null, the result is unspecified.Returns the value of the field named `field` on object `o`, taking
property getter functions into account.
If the field is not a property, this function behaves like
`Reflect.field`, but might be slower.
If `o` or `field` are null, the result is unspecified.Sets the field named `field` of object `o` to value `value`, taking
property setter functions into account.
If the field is not a property, this function behaves like
`Reflect.setField`, but might be slower.
If `field` is null, the result is unspecified.Returns the fields of structure `o`.
This method is only guaranteed to work on anonymous structures. Refer to
`Type.getInstanceFields` for a function supporting class instances.
If `o` is null, the result is unspecified.Removes the field named `field` from structure `o`.
This method is only guaranteed to work on anonymous structures.
If `o` or `field` are null, the result is unspecified.The Reflect API is a way to manipulate values dynamically through an
abstract interface in an untyped manner. Use with care.
@see https://haxe.org/manual/std-reflection.htmlTells if a value `v` is of the type `t`. Returns `false` if `v` or `t` are null.
If `t` is a class or interface with `@:generic` meta, the result is `false`.Converts any value to a String.
If `s` is of `String`, `Int`, `Float` or `Bool`, its value is returned.
If `s` is an instance of a class and that class or one of its parent classes has
a `toString` method, that method is called. If no such method is present, the result
is unspecified.
If `s` is an enum constructor without argument, the constructor's name is returned. If
arguments exists, the constructor's name followed by the String representations of
the arguments is returned.
If `s` is a structure, the field names along with their values are returned. The field order
and the operator separating field names and values are unspecified.
If s is null, "null" is returned.The Std class provides standard methods for manipulating basic types.The standard `Void` type. Only `null` values can be of the type `Void`.
@see https://haxe.org/manual/types-void.html` can be used instead.
`Std.int` converts a `Float` to an `Int`, rounded towards 0.
`Std.parseFloat` converts a `String` to a `Float`.
@see https://haxe.org/manual/types-basic-types.html
@see https://haxe.org/manual/types-nullability.html]]>` can be used instead.
`Std.int` converts a `Float` to an `Int`, rounded towards 0.
`Std.parseInt` converts a `String` to an `Int`.
@see https://haxe.org/manual/types-basic-types.html
@see https://haxe.org/manual/std-math-integer-math.html
@see https://haxe.org/manual/types-nullability.html]]>` is a wrapper that can be used to make the basic types `Int`,
`Float` and `Bool` nullable on static targets.
If null safety is enabled, only types wrapped in `Null` are nullable.
Otherwise, it has no effect on non-basic-types, but it can be useful as a way to document
that `null` is an acceptable value for a method argument, return value or variable.
@see https://haxe.org/manual/types-nullability.html]]>` can be used instead.
@see https://haxe.org/manual/types-bool.html
@see https://haxe.org/manual/types-nullability.html]]>`Dynamic` is a special type which is compatible with all other types.
Use of `Dynamic` should be minimized as it prevents several compiler
checks and optimizations. See `Any` type for a safer alternative for
representing values of any type.
@see https://haxe.org/manual/types-dynamic.htmlReturns the current item of the `Iterator` and advances to the next one.
This method is not required to check `hasNext()` first. A call to this
method while `hasNext()` is `false` yields unspecified behavior.
On the other hand, iterators should not require a call to `hasNext()`
before the first call to `next()` if an element is available.Returns `false` if the iteration is complete, `true` otherwise.
Usually iteration is considered to be complete if all elements of the
underlying data structure were handled through calls to `next()`. However,
in custom iterators any logic may be used to determine the completion
state.An `Iterator` is a structure that permits iteration over elements of type `T`.
Any class with matching `hasNext()` and `next()` fields is considered an `Iterator`
and can then be used e.g. in `for`-loops. This makes it easy to implement
custom iterators.
@see https://haxe.org/manual/lf-iterators.htmlAn `Iterable` is a data structure which has an `iterator()` method.
See `Lambda` for generic functions on iterable structures.
@see https://haxe.org/manual/lf-iterators.htmlA `KeyValueIterator` is an `Iterator` that has a key and a value.A `KeyValueIterable` is a data structure which has a `keyValueIterator()`
method to iterate over key-value-pairs.`ArrayAccess` is used to indicate a class that can be accessed using brackets.
The type parameter represents the type of the elements stored.
This interface should be used for externs only. Haxe does not support custom
array access on classes. However, array access can be implemented for
abstract types.
@see https://haxe.org/manual/types-abstract-array-access.htmlReturns the String corresponding to the character code `code`.
If `code` is negative or has another invalid value, the result is
unspecified.The number of characters in `this` String.Returns a String where all characters of `this` String are upper case.Returns a String where all characters of `this` String are lower case.Returns the character at position `index` of `this` String.
If `index` is negative or exceeds `this.length`, the empty String `""`
is returned.Returns the character code at position `index` of `this` String.
If `index` is negative or exceeds `this.length`, `null` is returned.
To obtain the character code of a single character, `"x".code` can be
used instead to inline the character code at compile time. Note that
this only works on String literals of length 1.Returns the position of the leftmost occurrence of `str` within `this`
String.
If `startIndex` is given, the search is performed within the substring
of `this` String starting from `startIndex`.
If `startIndex` exceeds `this.length`, -1 is returned.
If `startIndex` is negative, the result is unspecifed.
Otherwise the search is performed within `this` String. In either case,
the returned position is relative to the beginning of `this` String.
If `str` cannot be found, -1 is returned.Returns the position of the rightmost occurrence of `str` within `this`
String.
If `startIndex` is given, the search is performed within the substring
of `this` String from 0 to `startIndex + str.length`. Otherwise the search
is performed within `this` String. In either case, the returned position
is relative to the beginning of `this` String.
If `startIndex` is negative, the result is unspecifed.
If `str` cannot be found, -1 is returned.Splits `this` String at each occurrence of `delimiter`.
If `this` String is the empty String `""`, the result is not consistent
across targets and may either be `[]` (on Js, Cpp) or `[""]`.
If `delimiter` is the empty String `""`, `this` String is split into an
Array of `this.length` elements, where the elements correspond to the
characters of `this` String.
If `delimiter` is not found within `this` String, the result is an Array
with one element, which equals `this` String.
If `delimiter` is null, the result is unspecified.
Otherwise, `this` String is split into parts at each occurrence of
`delimiter`. If `this` String starts (or ends) with `delimiter`, the
result `Array` contains a leading (or trailing) empty String `""` element.
Two subsequent delimiters also result in an empty String `""` element.Returns `len` characters of `this` String, starting at position `pos`.
If `len` is omitted, all characters from position `pos` to the end of
`this` String are included.
If `pos` is negative, its value is calculated from the end of `this`
String by `this.length + pos`. If this yields a negative value, 0 is
used instead.
If the calculated position + `len` exceeds `this.length`, the characters
from that position to the end of `this` String are returned.
If `len` is negative, the result is unspecified.Returns the part of `this` String from `startIndex` to but not including `endIndex`.
If `startIndex` or `endIndex` are negative, 0 is used instead.
If `startIndex` exceeds `endIndex`, they are swapped.
If the (possibly swapped) `endIndex` is omitted or exceeds
`this.length`, `this.length` is used instead.
If the (possibly swapped) `startIndex` exceeds `this.length`, the empty
String `""` is returned.Returns the String itself.Creates a copy from a given String.The basic String class.
A Haxe String is immutable, it is not possible to modify individual
characters. No method of this class changes the state of `this` String.
Strings can be constructed using the String literal syntax `"string value"`.
String can be concatenated by using the `+` operator. If an operand is not a
String, it is passed through `Std.string()` first.
@see https://haxe.org/manual/std-String.htmlCreates an instance of class `cl`, using `args` as arguments to the
class constructor.
This function guarantees that the class constructor is called.
Default values of constructors arguments are not guaranteed to be
taken into account.
If `cl` or `args` are null, or if the number of elements in `args` does
not match the expected number of constructor arguments, or if any
argument has an invalid type, or if `cl` has no own constructor, the
result is unspecified.
In particular, default values of constructor arguments are not
guaranteed to be taken into account.Returns the index of enum instance `e`.
This corresponds to the original syntactic position of `e`. The index of
the first declared constructor is 0, the next one is 1 etc.
If `e` is null, the result is unspecified.The Haxe Reflection API allows retrieval of type information at runtime.
This class complements the more lightweight Reflect class, with a focus on
class and enum instances.
@see https://haxe.org/manual/types.html
@see https://haxe.org/manual/std-reflection.htmlThe unsigned `Int` type is only defined for Flash and C#.
Simulate it for other platforms.
@see https://haxe.org/manual/types-basic-types.html{ useWeakReference : false, priority : 0, useCapture : false }{ useCapture : false }{ useWeakReference : false, priority : 0, useCapture : false }{ useCapture : false }flash10flash10flash10flash10flash10flash10flash10{ shapeFlag : false }flash10flash11flash11flash11{ endIndex : 2147483647, beginIndex : 0 }flash11flash11_8{ lockCenter : false }{ lockCenter : false }flash10_1flash10_1flash10flash11Create a new `ArrayIterator`.` is passed to `Iterable`]]>0"anon_read.keyValueIterator""dynamic_read.keyValueIterator"false0
<__instanceof public="1" set="method" line="100" static="1">
<__clear_trace public="1" set="method" line="109" static="1">
<__set_trace_color public="1" set="method" line="117" static="1">
<__trace public="1" set="method" line="151" static="1">
<__string_rec public="1" set="method" line="171" static="1">
{ maxRecursion : 5 }
<__unprotect__ set="method" line="230" static="1">hidePlatform-specific Flash Library. Provides some platform-specific
functions for the Flash target.` values carry type parameter
information at run-time all the type-checks (such as `Std.isOfType` and `Std.downcast`) on them
must be done using a `Class` value that also carries the type parameters. However,
Haxe syntax does not allow creating such values and this function exists to mitigate
this limitation.
It should be used as such:
```haxe
var specificVectorType:Class> = Vector.typeReference();
trace(Std.isOfType(vec, specificVectorType));
```
or using the type-check syntax:
```haxe
trace(Std.isOfType(vec, (Vector.typeReference() : Class>)));
```
It's also helpful when working with native Flash libraries, that receive Class instances:
```haxe
new Signal((Vector.typeReference() : Class>));
```]]>flash19The Vector class is very similar to Array but is only supported by the Flash Player 10+flash10"flash.display.ActionScriptVersion""flash.display.ActionScriptVersion""flash.display.ActionScriptVersion"{ mergeAlpha : false }flash11_4{ smoothing : false }{ smoothing : false }flash11_3flash11_3{ findColor : true }flash10flash10{ secondAlphaThreshold : 1 }{ grayScale : false, channelOptions : 7, high : 255, low : 0 }{ grayScale : false, channelOptions : 7 }{ fillColor : 0, numPixels : 0, randomSeed : 0 }flash10{ copySource : false, mask : 0xFFFFFFFF, color : 0 }{ fillColor : 0xFFFFFFFF, transparent : true }"flash.display.BlendMode""flash.display.BlendMode""flash.display.BlendMode""flash.display.CapsStyle""flash.display.CapsStyle""flash.display.CapsStyle""flash.display.ColorCorrection"flash10_1"flash.display.ColorCorrection""flash.display.ColorCorrection""flash.display.ColorCorrectionSupport"flash10_1"flash.display.ColorCorrectionSupport""flash.display.ColorCorrectionSupport""flash.display.GradientType""flash.display.GradientType""flash.display.GradientType"{ smooth : false, repeat : true }{ alpha : 1 }{ focalPointRatio : 0 }flash10flash10flash11flash10flash10{ ellipseHeight : 0 }flash10{ smooth : false, repeat : true }flash10{ focalPointRatio : 0 }flash10{ miterLimit : 3, pixelHinting : false, alpha : 1, color : 0, thickness : 0 }{ recurse : true }flash11_6"flash.display.GraphicsPathWinding""flash.display.GraphicsPathWinding""flash.display.GraphicsPathWinding""flash.display.InterpolationMethod""flash.display.InterpolationMethod""flash.display.InterpolationMethod""flash.display.JointStyle""flash.display.JointStyle""flash.display.JointStyle""flash.display.LineScaleMode""flash.display.LineScaleMode""flash.display.LineScaleMode"flash10_1{ gc : true }flash10flash11_4flash10_1flash11_4flash10_1flash10_1flash10"flash.display.ShaderPrecision""flash.display.ShaderPrecision""flash.display.ShaderPrecision""flash.display.SpreadMethod""flash.display.SpreadMethod""flash.display.SpreadMethod"flash11_3flash10_2flash10flash10flash11_4flash11flash11_2flash11flash11flash10_2flash10_1flash12flash11"flash.display.StageAlign""flash.display.StageAlign""flash.display.StageAlign""flash.display.StageDisplayState""flash.display.StageDisplayState""flash.display.StageDisplayState""flash.display.StageQuality""flash.display.StageQuality""flash.display.StageQuality""flash.display.StageScaleMode""flash.display.StageScaleMode""flash.display.StageScaleMode""flash.display.TriangleCulling""flash.display.TriangleCulling""flash.display.TriangleCulling"flash12{ mask : 0xFFFFFFFF, stencil : 0, depth : 1, alpha : 1, blue : 0, green : 0, red : 0 }{ wantsBestResolutionOnBrowserZoom : false, wantsBestResolution : false, enableDepthAndStencil : true }{ streamingLevels : 0 }flash11_8{ streamingLevels : 0 }{ recreate : true }{ numTriangles : -1, firstIndex : 0 }flash11_2{ transposedMatrix : false }{ numRegisters : -1 }{ colorOutputIndex : 0, surfaceSelector : 0, antiAlias : 0, enableDepthAndStencil : false }flash11_6{ writeMask : 255, readMask : 255 }{ bufferOffset : 0 }"flash.display3D.Context3DBlendFactor""flash.display3D.Context3DBlendFactor""flash.display3D.Context3DBlendFactor""flash.display3D.Context3DBufferUsage"flash12"flash.display3D.Context3DBufferUsage""flash.display3D.Context3DBufferUsage""flash.display3D.Context3DCompareMode""flash.display3D.Context3DCompareMode""flash.display3D.Context3DCompareMode""flash.display3D.Context3DMipFilter""flash.display3D.Context3DMipFilter""flash.display3D.Context3DMipFilter""flash.display3D.Context3DProfile""flash.display3D.Context3DProfile""flash.display3D.Context3DProfile""flash.display3D.Context3DProgramType""flash.display3D.Context3DProgramType""flash.display3D.Context3DProgramType""flash.display3D.Context3DStencilAction""flash.display3D.Context3DStencilAction""flash.display3D.Context3DStencilAction""flash.display3D.Context3DTextureFilter""flash.display3D.Context3DTextureFilter""flash.display3D.Context3DTextureFilter""flash.display3D.Context3DTextureFormat""flash.display3D.Context3DTextureFormat""flash.display3D.Context3DTextureFormat""flash.display3D.Context3DTriangleFace""flash.display3D.Context3DTriangleFace""flash.display3D.Context3DTriangleFace""flash.display3D.Context3DVertexBufferFormat""flash.display3D.Context3DVertexBufferFormat""flash.display3D.Context3DVertexBufferFormat""flash.display3D.Context3DWrapMode""flash.display3D.Context3DWrapMode""flash.display3D.Context3DWrapMode"{ async : false }{ miplevel : 0 }{ miplevel : 0 }{ async : false }{ miplevel : 0 }{ miplevel : 0 }{ id : 0 }flash10flash11flash10flash10flash10flash10flash11_3flash10flash10flash11_3flash11_3flash11{ cancelable : false, bubbles : false }"flash.events.EventPhase""flash.events.EventPhase""flash.events.EventPhase"flash10_1{ knockout : false, inner : false, quality : 1, strength : 2, blurY : 6, blurX : 6, alpha : 1, color : 16711680 }{ alphaOffset : 0, blueOffset : 0, greenOffset : 0, redOffset : 0, alphaMultiplier : 1, blueMultiplier : 1, greenMultiplier : 1, redMultiplier : 1 }flash11flash11flash11flash11flash11{ ty : 0, tx : 0, rotation : 0 }{ ty : 0, tx : 0, rotation : 0 }flash11{ ty : 0, tx : 0, d : 1, c : 0, b : 0, a : 1 }flash11flash11flash11{ transpose : false, index : 0 }flash11{ transpose : false, index : 0 }flash11flash11flash11flash11flash10"flash.geom.Orientation3D""flash.geom.Orientation3D""flash.geom.Orientation3D"flash10flash11flash11{ y : 0, x : 0 }flash11flash11{ height : 0, width : 0, y : 0, x : 0 }flash10flash10flash10flash11{ allFour : false }{ allFour : false }flash11{ w : 0, z : 0, y : 0, x : 0 }flash10{ inBufferSeek : true }{ inBufferSeek : true }flash10_1
<_scanHardware public="1" set="method" static="1">
"flash.media"internalflash10_1flash11_2flash11_4flash11_4flash11_4{ compress : false }{ favorArea : true }{ timeout : 2000 }flash10_1{ index : -1 }flash10_2{ index : -1 }flash10flash10_1flash10flash10_2flash10flash10_1{ state : true }{ timeout : -1 }"flash.media.MicrophoneEnhancedMode"flash10_2"flash.media.MicrophoneEnhancedMode""flash.media.MicrophoneEnhancedMode"flash10_2"flash.media.SoundCodec""flash.media.SoundCodec""flash.media.SoundCodec"{ panning : 0, vol : 1 }flash11_7flash11_4flash10_2flash10flash10flash10flash10flash10flash10flash10{ mustUnderstand : false }flash10flash10flash10_1flash10_1flash10_1flash10_1flash10_1flash10_1flash10flash10flash10_1flash10flash10flash10_1flash10_1flash10_1flash10_1flash10_1flash10_1flash10_1flash10flash10flash11flash11_3flash10_1flash10_1flash11flash10_1flash10_1flash10_1{ snapshotMilliseconds : -1 }flash11_2flash10flash10flash10_1flash10_1{ isLive : true }flash10_1flash10_1{ wholeURL : false }flash10flash10flash11_3"flash.system.ImageDecodingPolicy""flash.system.ImageDecodingPolicy""flash.system.ImageDecodingPolicy"flash10_1flash10_1flash11flash11flash11{ checkPolicyFile : false }flash11_3"flash.text.AntiAliasType""flash.text.AntiAliasType""flash.text.AntiAliasType""flash.text.GridFitType""flash.text.GridFitType""flash.text.GridFitType"flash10flash11"flash.text"internal{ endIndex : -1, beginIndex : -1 }{ endIndex : 2147483647, beginIndex : 0 }{ endIndex : 2147483647, beginIndex : 0 }{ pasting : false }"flash.text"internal{ endIndex : -1, beginIndex : -1 }"flash.text.TextFieldAutoSize"
"flash.text.TextFormatAlign""flash.text.TextFormatDisplay""flash.text.TextFormatDisplay""flash.text.TextFormatDisplay""flash.text.TextInteractionMode""flash.text.TextInteractionMode""flash.text.TextInteractionMode"{ includeLineEndings : false }{ includeLineEndings : false }{ maxDistance : 0 }{ hexColor : 16776960 }flash10_1flash10flash10flash10{ length : 0, offset : 0 }{ length : 0, offset : 0 }flash11_4flash11_4flash11_4flash10flash10flash10{ length : 0, offset : 0 }{ length : 0, offset : 0 }"flash.utils.CompressionAlgorithm"flash11"flash.utils.CompressionAlgorithm""flash.utils.CompressionAlgorithm"{ weakKeys : false }"flash.utils.Endian""flash.utils.Endian""flash.utils.Endian"flash11flash11Get information about the call stack.haxe.Exceptionhaxe.CallStackhaxe.CallStackhaxe.ExceptionThis type unifies with any function type.
It is intended to be used as a type parameter constraint. If used as a real
type, the underlying type will be `Dynamic`.This type unifies with an enum instance if all constructors of the enum
require no arguments.
It is intended to be used as a type parameter constraint. If used as a real
type, the underlying type will be `Dynamic`.This type unifies with anything but `Void`.
It is intended to be used as a type parameter constraint. If used as a real
type, the underlying type will be `Dynamic`.`, A must be explicitly constrained to
`Constructible` as well.
It is intended to be used as a type parameter constraint. If used as a real
type, the underlying type will be `Dynamic`.]]>Returns the name of enum `e`, including its path.
If `e` is inside a package, the package structure is returned dot-
separated, with another dot separating the enum name:
pack1.pack2.(...).packN.EnumName
If `e` is a sub-type of a Haxe module, that module is not part of the
package structure.
If `e` has no package, the enum name is returned.
If `e` is `null`, the result is unspecified.
The enum name does not include any type parameters.Creates an instance of enum `e` by calling its constructor `constr` with
arguments `params`.
If `e` or `constr` is `null`, or if enum `e` has no constructor named
`constr`, or if the number of elements in `params` does not match the
expected number of constructor arguments, or if any argument has an
invalid type, the result is unspecified.Creates an instance of enum `e` by calling its constructor number
`index` with arguments `params`.
The constructor indices are preserved from Haxe syntax, so the first
declared is index 0, the next index 1 etc.
If `e` or `index` is `null`, or if enum `e` has no constructor
corresponding to index `index`, or if the number of elements in `params`
does not match the expected number of constructor arguments, or if any
argument has an invalid type, the result is unspecified.Returns a list of all constructors of enum `e` that require no
arguments.
This may return the empty Array `[]` if all constructors of `e` require
arguments.
Otherwise an instance of `e` constructed through each of its non-
argument constructors is returned, in the order of the constructor
declaration.
If `e` is `null`, the result is unspecified.Returns a list of the names of all constructors of enum `e`.
The order of the constructor names in the returned Array is preserved
from the original syntax.
If `c` is `null`, the result is unspecified.This class provides advanced methods on enums. It is ideally used with
`using EnumTools` and then acts as an
[extension](https://haxe.org/manual/lf-static-extension.html) to the
`enum` types.
If the first argument to any of the methods is `null`, the result is
unspecified.Recursively compares two enum instances `a` and `b` by value.
Unlike `a == b`, this function performs a deep equality check on the
arguments of the constructors (if there are any).
If `a` or `b` are `null`, the result is unspecified.Returns the constructor name of enum instance `e`.
The result String does not contain any constructor arguments.
If `e` is `null`, the result is unspecified.Returns a list of the constructor arguments of enum instance `e`.
If `e` has no arguments, the result is `[]`.
Otherwise the result are the values that were used as arguments to `e`,
in the order of their declaration.
If `e` is `null`, the result is unspecified.Returns the index of enum instance `e`.
This corresponds to the original syntactic position of `e`. The index of
the first declared constructor is 0, the next one is 1 etc.
If `e` is `null`, the result is unspecified.This class provides advanced methods on enum values. It is ideally used with
`using EnumValueTools` and then acts as an
[extension](https://haxe.org/manual/lf-static-extension.html) to the
`EnumValue` types.
If the first argument to any of the methods is `null`, the result is
unspecified.{ id : 0 }hide"flash.errors.Error"Native exception, which caused this exception.
<__nativeStack>
<__skipStack>
"haxe.Exception.get_stack"
<__nativeException>
<__previousException>
Create a new Exception instance.
The `previous` argument could be used for exception chaining.
The `native` argument is for internal usage only.
There is no need to provide `native` argument manually and no need to keep it
upon extending `haxe.Exception` unless you know what you're doing. = null;
a.push(1); // generates target-specific null-pointer exception
} catch(e:haxe.Exception) {
throw e; // rethrows native exception instead of haxe.Exception
}
```]]>{ skipItems : 0 }{ pos : 0 }Do not use manually.hidehaxe.Exception`PosInfos` is a magic type which can be used to generate position information
into the output for debugging use.
If a function has a final optional argument of this type, i.e.
`(..., ?pos:haxe.PosInfos)`, each call to that function which does not assign
a value to that argument has its position added as call argument.
This can be used to track positions of calls in e.g. a unit testing
framework.
}
f(1, 2, 3);
final array = [1, 2, 3];
f(...array);
```
Should be used as a type for the last argument of a method, indicating that
an arbitrary number of arguments of the given type can be passed to that method.
Allows to use array access by index to get values of rest arguments.
If the index exceeds the amount of rest arguments passed, the result is unspecified.]]>Thrown value.An exception containing arbitrary value.
This class is automatically used for throwing values, which don't extend `haxe.Exception`
or native exception type.
For example:
```haxe
throw "Terrible error";
```
will be compiled to
```haxe
throw new ValueException("Terrible error");
```See `Map.get`See `Map.remove`See `Map.keys`
(cs, java) Implementation detail: Do not `set()` any new value while
iterating, as it may cause a resize, which will break iteration.See `Map.iterator`
(cs, java) Implementation detail: Do not `set()` any new value while
iterating, as it may cause a resize, which will break iteration.Creates a new ObjectMap.ObjectMap allows mapping of object keys to arbitrary values.
On static targets, the keys are considered to be strong references. Refer
to `haxe.ds.WeakMap` for a weak reference version.
See `Map` for documentation details.
@see https://haxe.org/manual/std-Map.html00]]>See `Iterator.hasNext`See `Iterator.next`This Key/Value iterator can be used to iterate across maps."anon_read.keyValueIterator""dynamic_read.keyValueIterator"* Flash performs faster when objects are set to visible = false rather than only alpha = 0. autoVisible toggles automatically based on alpha values
* @param value Whether autoVisible should be enabled (Default is true)
* @return The current actuator instance* Increases the delay before a tween is executed
* @param duration The amount of seconds to delay
* @return The current actuator instance* Sets the easing which is used when running the tween
* @param easing An easing equation, like Elastic.easeIn or Quad.easeOut
* @return The current actuator instance* Defines a function which will be called when the tween finishes
* @param handler The function you would like to be called
* @param parameters Parameters you would like to pass to the handler function when it is called
* @return The current actuator instance* Defines a function which will be called when the tween repeats
* @param handler The function you would like to be called
* @param parameters Parameters you would like to pass to the handler function when it is called
* @return The current actuator instance* Defines a function which will be called when the tween updates
* @param handler The function you would like to be called
* @param parameters Parameters you would like to pass to the handler function when it is called
* @return The current actuator instance* Automatically changes the reverse value when the tween repeats. Repeat must be enabled for this to have any effect
* @param value Whether reflect should be enabled (Default is true)
* @return The current actuator instance* Repeats the tween after it finishes
* @param times The number of times you would like the tween to repeat, or -1 if you would like to repeat the tween indefinitely (Default is -1)
* @return The current actuator instance* Sets if the tween should be handled in reverse
* @param value Whether the tween should be reversed (Default is true)
* @return The current actuator instance* Enabling smartRotation can prevent undesired results when tweening rotation values
* @param value Whether smart rotation should be enabled (Default is true)
* @return The current actuator instance* Snapping causes tween values to be rounded automatically
* @param value Whether tween values should be rounded (Default is true)
* @return The current actuator instance* Defines a function which will be called when the tween is paused
* @param handler The function you would like to be called
* @param parameters Parameters you would like to pass to the handler function when it is called
* @return The current actuator instance* Defines a function which will be called when the tween resumed after pause
* @param handler The function you would like to be called
* @param parameters Parameters you would like to pass to the handler function when it is called
* @return The current actuator instance
<_autoVisible>
<_delay>
<_ease>
<_onComplete>
<_onCompleteParams>
<_onRepeat>
<_onRepeatParams>
<_onUpdate>
<_onUpdateParams>
<_onResume>
<_onResumeParams>
<_onPause>
<_onPauseParams>
<_reflect>
<_repeat>
<_reverse>
<_smartRotation>
<_snapping>* Flash performs faster when objects are set to visible = false rather than only alpha = 0. autoVisible toggles automatically based on alpha values
* @param value Whether autoVisible should be enabled (Default is true)
* @return The current actuator instance{ params : null }{ sendEvent : true }* Increases the delay before a tween is executed
* @param duration The amount of seconds to delay
* @return The current actuator instance* Sets the easing which is used when running the tween
* @param easing An easing equation, like Elastic.easeIn or Quad.easeOut
* @return The current actuator instance{ parameters : null }* Defines a function which will be called when the tween finishes
* @param handler The function you would like to be called
* @param parameters Parameters you would like to pass to the handler function when it is called
* @return The current actuator instance{ parameters : null }* Defines a function which will be called when the tween repeats
* @param handler The function you would like to be called
* @param parameters Parameters you would like to pass to the handler function when it is called
* @return The current actuator instance{ parameters : null }* Defines a function which will be called when the tween updates
* @param handler The function you would like to be called
* @param parameters Parameters you would like to pass to the handler function when it is called
* @return The current actuator instance{ parameters : null }* Defines a function which will be called when the tween is paused
* @param handler The function you would like to be called
* @param parameters Parameters you would like to pass to the handler function when it is called
* @return The current actuator instance{ parameters : null }* Defines a function which will be called when the tween resumed after pause
* @param handler The function you would like to be called
* @param parameters Parameters you would like to pass to the handler function when it is called
* @return The current actuator instance* Automatically changes the reverse value when the tween repeats. Repeat must be enabled for this to have any effect
* @param value Whether reflect should be enabled (Default is true)
* @return The current actuator instance* Repeats the tween after it finishes
* @param times The number of times you would like the tween to repeat, or -1 if you would like to repeat the tween indefinitely (Default is -1)
* @return The current actuator instance* Sets if the tween should be handled in reverse
* @param value Whether the tween should be reversed (Default is true)
* @return The current actuator instance* Enabling smartRotation can prevent undesired results when tweening rotation values
* @param value Whether smart rotation should be enabled (Default is true)
* @return The current actuator instance* Snapping causes tween values to be rounded automatically
* @param value Whether tween values should be rounded (Default is true)
* @return The current actuator instance>()]]>0false* @inheritDoc* @inheritDoc* @inheritDoc{ parameters : null }* @inheritDoc* @author Joshua Granick
* @author Philippe / http://philippe.elsass.menew ExpoEaseIn()new ExpoEaseInOut()new ExpoEaseOut()* @author Joshua Granick
* @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.htmlSimpleActuatorExpo.easeOut>()]]>{ customActuator : null }Actuate.apply (MyClip, { alpha: 1 } );
* @param target The object to copy to
* @param properties The object to copy from
* @param customActuator A custom actuator to use instead of the default (Optional)
* @return The current actuator instance, which can be used to apply properties like onComplete or onUpdate handlers]]>{ overwrite : true }* Creates a new effects tween
* @param target The object to tween
* @param duration The length of the tween in seconds
* @param overwrite Sets whether previous tweens for the same target and properties will be overwritten (Default is true)
* @return An EffectsOptions instance, which is used to select the kind of effect you would like to apply to the target{ allowCreation : true }* Checks if Actuate has any active tweens
* @return Whether Actuate is active{ overwrite : true }* Creates a new MotionPath tween
* @param target The object to tween
* @param duration The length of the tween in seconds
* @param properties An object containing a motion path for each property you wish to tween
* @param overwrite Sets whether previous tweens for the same target and properties will be overwritten (Default is true)
* @return The current actuator instance, which can be used to apply properties like ease, delay, onComplete or onUpdate* Pauses tweens for the specified target objects
* @param ... targets The target objects which will have their tweens paused. Passing no value pauses tweens for all objects* Resets Actuate by stopping and removing tweens for all objects* Resumes paused tweens for the specified target objects
* @param ... targets The target objects which will have their tweens resumed. Passing no value resumes tweens for all objects{ sendEvent : true, complete : false, properties : null }* Stops all tweens for an individual object
* @param target The target object which will have its tweens stopped, or a generic actuator instance
* @param properties A string, array or object which contains the properties you wish to stop, like "alpha", [ "x", "y" ] or { alpha: null }. Passing no value removes all tweens for the object (Optional)
* @param complete If tweens should apply their final target values before stopping. Default is false (Optional)
* @param sendEvent If a complete() event should be dispatched for the specified target. Default is true (Optional){ customActuator : null }Actuate.timer (1).onComplete (trace, [ "Timer is now complete" ]);
* @param duration The length of the timer in seconds
* @param customActuator A custom actuator to use instead of the default (Optional)
* @return The current actuator instance, which can be used to apply properties like onComplete or to gain a reference to the target timer object]]>{ overwrite : true, duration : 0 }Actuate.transform (MyClip, 1).color (0xFF0000);
* @param target The object to tween
* @param duration The length of the tween in seconds
* @param overwrite Sets whether previous tweens for the same target and properties will be overwritten (Default is true)
* @return A TransformOptions instance, which is used to select the kind of transform you would like to apply to the target]]>{ customActuator : null, overwrite : true }Actuate.tween (MyClip, 1, { alpha: 1 } ).onComplete (trace, [ "MyClip is now visible" ]);
* @param target The object to tween
* @param duration The length of the tween in seconds
* @param properties The end values to tween the target to
* @param overwrite Sets whether previous tweens for the same target and properties will be overwritten (Default is true)
* @param customActuator A custom actuator to use instead of the default (Optional)
* @return The current actuator instance, which can be used to apply properties like ease, delay, onComplete or onUpdate]]>{ overwrite : true, end : null, start : null }Actuate.update (trace, 1, ["Value: ", 0], ["", 1]).onComplete (trace, [ "Finished tracing values between 0 and 1" ]);
* @param target The method to update
* @param duration The length of the tween in seconds
* @param start The starting parameters of the method call. You may use both numeric and non-numeric values
* @param end The ending parameters of the method call. You may use both numeric and non-numeric values, but the signature should match the start parameters
* @param overwrite Sets whether previous tweens for the same target and properties will be overwritten (Default is true)
* @return The current actuator instance, which can be used to apply properties like ease, delay, onComplete or onUpdate]]>motion.actuators* Creates a new BitmapFilter tween
* @param reference A reference to the target's filter, which can be an array index or the class of the filter
* @param properties The end properties to use for the tween
* @return The current actuator instance, which can be used to apply properties like ease, delay, onComplete or onUpdate{ alpha : null, strength : 1, value : 0x000000 }* Creates a new ColorTransform tween
* @param color The color value
* @param strength The percentage amount of tint to apply (Default is 1)
* @param alpha The end alpha of the target. If you wish to tween alpha and tint simultaneously, you must do them both as part of the ColorTransform. A value of null will make no change to the alpha of the object (Default is null)
* @return The current actuator instance, which can be used to apply properties like ease, delay, onComplete or onUpdate{ pan : null, volume : null }* Creates a new SoundTransform tween
* @param volume The end volume for the target, or null if you would like to ignore this property (Default is null)
* @param pan The end pan for the target, or null if you would like to ignore this property (Default is null)
* @return The current actuator instance, which can be used to apply properties like ease, delay, onComplete or onUpdate
<_rotation>
<_x>
<_y>{ strength : 1 }* Adds a quadratic (1 control point) bezier curve to the current motion path
* @param x The x position of the end point for the curve
* @param y The y position of the end point for the curve
* @param controlX The x position of the control point for the curve, which affects the angle and midpoint
* @param controlY The y position of the control point for the curve, which affects the angle and midpoint
* @param strength The degree of emphasis that should be placed on this segment. If a motion path contains multiple segments with the same strength, they all receive equal emphasis (Default is 1)
* @return The current motion path instance{ strength : 1 }* Adds a bezier curve of arbitrary degree to the current motion path
* @param x The x position of the end point for the curve
* @param y The y position of the end point for the curve
* @param controlX The x positions of the control points for the curve, which affects the angle and midpoint. The number of control points determines the degree of the curve
* @param controlY The y positions of the control points for the curve, which affects the angle and midpoint. The number of control points determines the degree of the curve
* @param strength The degree of emphasis that should be placed on this segment. If a motion path contains multiple segments with the same strength, they all receive equal emphasis (Default is 1)
* @return The current motion path instance{ strength : 1 }* Adds a smooth bezier spline that passes through a given set of points
* @param x The x positions of the points to pass through
* @param y The y positions of the points to pass through
* @param strength The degree of emphasis that should be placed on this segment. If a motion path contains multiple segments with the same strength, they all receive equal emphasis (Default is 1)
* @return The current motion path instance{ strength : 1 }* Adds a line to the current motion path
* @param x The x position of the end point for the line
* @param x The y position of the end point for the line
* @param strength The degree of emphasis that should be placed on this segment . If a motion path contains multiple segments with the same strength, they all receive equal emphasis (Default is 1)
* @return The current motion path instance
<_start>
<_end>
<_start>0.01
<_x>
<_y>{ sendEvent : true }{ isField : true }{ isField : true }new BackEaseIn(1.70158)new BackEaseInOut(1.70158)new BackEaseOut(1.70158)* @author Joshua Granick
* @author Zeh Fernando, Nate Chatellier
* @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html
<_ease public="1" get="inline" set="null" line="37" static="1">
<_ease public="1" get="inline" set="null" line="101" static="1">new BounceEaseIn()new BounceEaseInOut()new BounceEaseOut()* @author Erik Escoffier
* @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.htmlnew CubicEaseIn()new CubicEaseInOut()new CubicEaseOut()* @author Joshua Granick
* @author Philippe / http://philippe.elsass.me
* @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html
new ElasticEaseIn(0.1, 0.4)new ElasticEaseInOut(0.1, 0.4)new ElasticEaseOut(0.1, 0.4)* @author Joshua Granick
* @author Philippe / http://philippe.elsass.me
* @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html* @author Joshua Granick
* @author Philippe / http://philippe.elsass.me
* @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.htmlnew QuadEaseIn()new QuadEaseInOut()new QuadEaseOut()* @author Joshua Granick
* @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.htmlnew QuartEaseIn()new QuartEaseInOut()new QuartEaseOut()* @author Joshua Granick
* @author Philippe / http://philippe.elsass.me
* @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.htmlnew QuintEaseIn()new QuintEaseInOut()new QuintEaseOut()* @author Joshua Granick
* @author Philippe / http://philippe.elsass.me
* @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.htmlnew SineEaseIn()new SineEaseInOut()new SineEaseOut()* @author Joshua Granick
* @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html