@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/lib/utils/AwayDate.ts

@@ -0,0 +1,64 @@
+import { Debug } from '@awayjs/core';
+
+export class AwayDate {
+	// @todo check why this differs from the header file i converted from as3
+	// just made it compatible for compile right now
+	//yearOrTimevalue:number,month:number,date:number,hour:number,minute:number,second:number,millisecond:number){
+	constructor(param1: any = 0, param2: number = 0, param3: number = 0) {
+		// @todo
+		Debug.throwPIR('playerglobals/utils/AwayDate', 'AwayDate-constructor', '');
+	}
+
+	public date: number;
+	public fullYear: number;
+	public month: number;
+
+	public static UTC(year: number, month: number, date: number,
+		hour: number, minute: number, second: number,
+		millisecond: number): number {
+		return 0;
+	}
+
+	public getDate(): number { return 0; }
+	public getDay(): number { return 0; }
+	public getFullYear(): number { return 0; }
+	public getHours(): number { return 0; }
+	public getMilliseconds(): number { return 0; }
+	public getMinutes(): number { return 0; }
+	public getMonth(): number { return 0; }
+	public getSeconds(): number { return 0; }
+	public getTime(): number { return 0; }
+	public getTimezoneOffset(): number { return 0; }
+	public getUTCDate(): number { return 0; }
+	public getUTCDay(): number { return 0; }
+	public getUTCFullYear(): number { return 0; }
+	public getUTCHours(): number { return 0; }
+	public getUTCMilliseconds(): number { return 0; }
+	public getUTCMinutes(): number { return 0; }
+	public getUTCMonth(): number { return 0; }
+	public getUTCSeconds(): number { return 0; }
+	public getYear(): number { return 0; }
+	public setDate(date: number): number { return 0; }
+	public setFullYear(year: number, month: number, date: number): number { return 0; }
+	public setHours(hour: number): number { return 0; }
+	public setMilliseconds(millisecond: number): number { return 0; }
+	public setMinutes(minute: number): number { return 0; }
+	public setMonth(month: number, date: number): number { return 0; }
+	public setSeconds(second: number): number { return 0; }
+	public setTime(millisecond: number): number { return 0; }
+	public setUTCDate(date: number): number { return 0; }
+	public setUTCFullYear(year: number, month: number, date: number): number { return 0; }
+	public setUTCHours(hour: number, minute: number, second: number, millisecond: number): number { return 0; }
+	public setUTCMilliseconds(millisecond: number): number { return 0; }
+	public setUTCMinutes(minute: number, second: number, millisecond: number): number { return 0; }
+	public setUTCMonth(month: number, date: number): number { return 0; }
+	public setUTCSeconds(second: number, millisecond: number): number { return 0; }
+	public setYear(year: number): number { return 0; }
+	public toString(): string { return ''; }
+	public valueOf(): number { return 0; }
+
+	// Mobile specific
+	public getLocaleLongDate(): string { return ''; }
+	public getLocaleShortDate(): string { return ''; }
+	public getLocaleTime(): string { return ''; }
+}

package/lib/utils/ByteArray.ts

@@ -0,0 +1 @@
+export { ByteArray } from '@awayjs/core';

package/lib/utils/CompressionAlgorithm.ts

@@ -0,0 +1,7 @@
+import { ASObject } from '@awayfl/avm2';
+
+export class CompressionAlgorithm extends ASObject {
+	static $BgDEFLATE: string = 'deflate';
+	static $BgLZMA: string = 'lzma';
+	static $BgZLIB: string = 'zlib'
+}

package/lib/utils/Dictionary.ts

@@ -0,0 +1 @@
+export const Dictionary = Object;

package/lib/utils/Endian.ts

@@ -0,0 +1,15 @@
+export class Endian {
+
+	/**
+	 * Indicates the most significant byte of the multibyte number appears first in the sequence of bytes.
+	 * The hexadecimal number 0x12345678 has 4 bytes (2 hexadecimal digits per byte).
+	 */
+	public static BIG_ENDIAN: string = 'bigEndian';
+
+	/**
+	 * Indicates the least significant byte of the multibyte number appears first in the sequence of bytes.
+	 * The hexadecimal number 0x12345678 has 4 bytes (2 hexadecimal digits per byte).
+	 */
+	public static LITTLE_ENDIAN: string = 'littleEndian';
+
+}

package/lib/utils/IDataInput.ts

@@ -0,0 +1,194 @@
+import { ByteArray } from './ByteArray';
+
+/**
+ * The IDataInput interface provides a set of methods for reading binary data.
+ * This interface is the I/O counterpart to the IDataOutput interface, which
+ * writes binary data.
+ * <p class="- topic/p ">All IDataInput and IDataOutput operations are "bigEndian" by default (the most significant
+ * byte in the sequence is stored at the lowest or first storage address),
+ * and are nonblocking.
+ * If insufficient data is available, an <codeph class="+ topic/ph pr-d/codeph ">EOFError</codeph> exception
+ * is thrown. Use the <codeph class="+ topic/ph pr-d/codeph ">IDataInput.bytesAvailable</codeph> property to determine
+ * how much data is available to read.</p><p class="- topic/p ">
+ * Sign extension matters only when you read data, not when you write it. Therefore you do not need separate
+ * write methods to work with <codeph class="+ topic/ph pr-d/codeph ">IDataInput.readUnsignedByte()</codeph> and
+ * <codeph class="+ topic/ph pr-d/codeph ">IDataInput.readUnsignedShort()</codeph>.
+ * In other words:</p><ul class="- topic/ul "><li class="- topic/li ">Use
+ * <codeph class="+ topic/ph pr-d/codeph ">IDataOutput.writeByte()</codeph> with
+ * <codeph class="+ topic/ph pr-d/codeph ">IDataInput.readUnsignedByte()</codeph> and
+ * <codeph class="+ topic/ph pr-d/codeph ">IDataInput.readByte()</codeph>.</li>
+ * <li class="- topic/li ">Use <codeph class="+ topic/ph pr-d/codeph ">
+ * IDataOutput.writeShort()</codeph> with <codeph class="+ topic/ph pr-d/codeph ">
+ * IDataInput.readUnsignedShort()</codeph> and
+ * <codeph class="+ topic/ph pr-d/codeph ">IDataInput.readShort()</codeph>.</li></ul>
+ */
+export interface IDataInput
+{
+	/**
+	 * Returns the number of bytes of data available for reading
+	 * in the input buffer.
+	 * User code must call bytesAvailable to ensure
+	 * that sufficient data is available before trying to read
+	 * it with one of the read methods.
+	 */
+	bytesAvailable: number;
+
+	/**
+	 * The byte order for the data, either the BIG_ENDIAN or LITTLE_ENDIAN constant
+	 * from the Endian class.
+	 */
+	endian: string;
+	/*function set endian (type:String)*/
+
+	/**
+	 * Used to determine whether the AMF3 or AMF0 format is used when writing or reading binary data using the
+	 * readObject() method. The value is a constant from the ObjectEncoding class.
+	 */
+	objectEncoding: number;
+	/*function set objectEncoding (version:uint)*/
+
+	/**
+	 * Reads a Boolean value from the file stream, byte stream, or byte array. A single byte is read
+	 * and true is returned if the byte is nonzero,
+	 * false otherwise.
+	 * @return	A Boolean value, true if the byte is nonzero,
+	 *   false otherwise.
+	 * @throws	EOFError There is not sufficient data available
+	 *   to read.
+	 */
+	readBoolean (): boolean;
+
+	/**
+	 * Reads a signed byte from the file stream, byte stream, or byte array.
+	 * @return	The returned value is in the range -128 to 127.
+	 * @throws	EOFError There is not sufficient data available
+	 *   to read.
+	 */
+	readByte (): number;
+
+	/**
+	 * Reads the number of data bytes, specified by the length parameter,
+	 * from the file stream, byte stream, or byte array. The bytes are read into the
+	 * ByteArray objected specified by the bytes parameter, starting at
+	 * the position specified by offset.
+	 * @param	bytes	The ByteArray object to read
+	 *   data into.
+	 * @param	offset	The offset into the bytes parameter at which data
+	 *   read should begin.
+	 * @param	length	The number of bytes to read.  The default value
+	 *   of 0 causes all available data to be read.
+	 * @throws	EOFError There is not sufficient data available
+	 *   to read.
+	 */
+	readBytes (bytes: ByteArray, offset: number, length: number);
+
+	/**
+	 * Reads an IEEE 754 double-precision floating point number from the file stream, byte stream, or byte array.
+	 * @return	An IEEE 754 double-precision floating point number.
+	 * @throws	EOFError There is not sufficient data available
+	 *   to read.
+	 */
+	readDouble (): number;
+
+	/**
+	 * Reads an IEEE 754 single-precision floating point number from the file stream, byte stream, or byte array.
+	 * @return	An IEEE 754 single-precision floating point number.
+	 * @throws	EOFError There is not sufficient data available
+	 *   to read.
+	 */
+	readFloat (): number;
+
+	/**
+	 * Reads a signed 32-bit integer from the file stream, byte stream, or byte array.
+	 * @return	The returned value is in the range -2147483648 to 2147483647.
+	 * @throws	EOFError There is not sufficient data available
+	 *   to read.
+	 */
+	readInt (): number;
+
+	/**
+	 * Reads a multibyte string of specified length from the file stream, byte stream, or byte array using the
+	 * specified character set.
+	 * @param	length	The number of bytes from the byte stream to read.
+	 * @param	charSet	The string denoting the character set to use to interpret the bytes.
+	 *   Possible character set strings include "shift-jis", "cn-gb",
+	 *   "iso-8859-1", and others.
+	 *   For a complete list, see Supported Character Sets.
+	 *
+	 *     Note: If the value for the charSet parameter is not recognized by the current
+	 *   system, then Adobe® Flash® Player or
+	 *   Adobe® AIR® uses the system's default
+	 *   code page as the character set. For example, a value for the charSet parameter, as in
+	 *   myTest.readMultiByte(22, "iso-8859-01"), that uses  01 instead of
+	 *   1 might work on your development system, but not on another system. On the other
+	 *   system, Flash Player or the AIR runtime will use the system's
+	 *   default code page.
+	 * @return	UTF-8 encoded string.
+	 * @throws	EOFError There is not sufficient data available
+	 *   to read.
+	 */
+	readMultiByte (length: number, charSet: string): string;
+
+	/**
+	 * Reads an object from the file stream, byte stream, or byte array, encoded in AMF
+	 * serialized format.
+	 * @return	The deserialized object
+	 * @throws	EOFError There is not sufficient data available
+	 *   to read.
+	 */
+	readObject (): any;
+
+	/**
+	 * Reads a signed 16-bit integer from the file stream, byte stream, or byte array.
+	 * @return	The returned value is in the range -32768 to 32767.
+	 * @throws	EOFError There is not sufficient data available
+	 *   to read.
+	 */
+	readShort (): number;
+
+	/**
+	 * Reads an unsigned byte from the file stream, byte stream, or byte array.
+	 * @return	The returned value is in the range 0 to 255.
+	 * @throws	EOFError There is not sufficient data available
+	 *   to read.
+	 */
+	readUnsignedByte (): number;
+
+	/**
+	 * Reads an unsigned 32-bit integer from the file stream, byte stream, or byte array.
+	 * @return	The returned value is in the range 0 to 4294967295.
+	 * @throws	EOFError There is not sufficient data available
+	 *   to read.
+	 */
+	readUnsignedInt (): number;
+
+	/**
+	 * Reads an unsigned 16-bit integer from the file stream, byte stream, or byte array.
+	 * @return	The returned value is in the range 0 to 65535.
+	 * @throws	EOFError There is not sufficient data available
+	 *   to read.
+	 */
+	readUnsignedShort (): number;
+
+	/**
+	 * Reads a UTF-8 string from the file stream, byte stream, or byte array.  The string
+	 * is assumed to be prefixed with an unsigned short indicating
+	 * the length in bytes.
+	 *
+	 *   This method is similar to the readUTF()
+	 * method in the Java® IDataInput interface.
+	 * @return	A UTF-8 string produced by the byte representation of characters.
+	 * @throws	EOFError There is not sufficient data available
+	 *   to read.
+	 */
+	readUTF (): string;
+
+	/**
+	 * Reads a sequence of UTF-8 bytes from the byte stream or byte array and returns a string.
+	 * @param	length	The number of bytes to read.
+	 * @return	A UTF-8 string produced by the byte representation of characters of the specified length.
+	 * @throws	EOFError There is not sufficient data available
+	 *   to read.
+	 */
+	readUTFBytes (length: number): string;
+}

package/lib/utils/IDataOutput.ts

@@ -0,0 +1,147 @@
+import { ByteArray } from './ByteArray';
+
+/**
+ * The IDataOutput interface provides a set of methods for writing binary data.
+ * This interface is the I/O counterpart to the IDataInput interface, which
+ * reads binary data. The IDataOutput interface is implemented by the FileStream, Socket
+ * and ByteArray classes.
+ * <p class="- topic/p ">All IDataInput and IDataOutput operations are "bigEndian" by default (the most significant
+ * byte in the sequence is stored at the lowest or first storage address),
+ * and are nonblocking. </p><p class="- topic/p ">Sign extension matters only when you read data,
+ * not when you write it. Therefore, you do not need separate
+ * write methods to work with <codeph class="+ topic/ph pr-d/codeph ">IDataInput.readUnsignedByte()</codeph> and
+ * <codeph class="+ topic/ph pr-d/codeph ">IDataInput.readUnsignedShort()</codeph>.
+ * In other words:</p><ul class="- topic/ul "><li class="- topic/li ">Use <codeph class="+ topic/ph pr-d/codeph ">
+ * IDataOutput.writeByte()</codeph> with <codeph class="+ topic/ph pr-d/codeph ">
+ * IDataInput.readUnsignedByte()</codeph> and
+ * <codeph class="+ topic/ph pr-d/codeph ">IDataInput.readByte()</codeph>.</li>
+ * <li class="- topic/li ">Use <codeph class="+ topic/ph pr-d/codeph ">
+ * IDataOutput.writeShort()</codeph> with <codeph class="+ topic/ph pr-d/codeph ">
+ * IDataInput.readUnsignedShort()</codeph> and
+ * <codeph class="+ topic/ph pr-d/codeph ">IDataInput.readShort()</codeph>.</li></ul>
+ */
+export interface IDataOutput
+{
+	/**
+	 * The byte order for the data, either the BIG_ENDIAN or LITTLE_ENDIAN
+	 * constant from the Endian class.
+	 */
+	endian: string;
+	/*function set endian (type:String)*/
+
+	/**
+	 * Used to determine whether the AMF3 or AMF0 format is used when writing or reading binary data using the
+	 * writeObject() method. The value is a constant from the ObjectEncoding class.
+	 */
+	objectEncoding: number;
+	/*function set objectEncoding (version:uint)*/
+
+	/**
+	 * Writes a Boolean value. A single byte is written according to the value parameter,
+	 * either 1 if true or 0 if false.
+	 * @param	value	A Boolean value determining which byte is written. If the parameter is true,
+	 *   1 is written; if false, 0 is written.
+	 * @internal	throws IOError An I/O error occurred?
+	 */
+	writeBoolean (value: boolean)
+
+	/**
+	 * Writes a byte.
+	 * The low 8 bits of the
+	 * parameter are used; the high 24 bits are ignored.
+	 * @param	value	A byte value as an integer.
+	 * @internal	throws IOError An I/O error occurred?
+	 */
+	writeByte (value: number)
+
+	/**
+	 * Writes a sequence of bytes from the
+	 * specified byte array, bytes,
+	 * starting at the byte specified by offset
+	 * (using a zero-based index)
+	 * with a length specified by length,
+	 * into the file stream, byte stream, or byte array.
+	 *
+	 *   If the length parameter is omitted, the default
+	 * length of 0 is used and the entire buffer starting at
+	 * offset is written.
+	 * If the offset parameter is also omitted, the entire buffer is
+	 * written. If the offset or length parameter
+	 * is out of range, they are clamped to the beginning and end
+	 * of the bytes array.
+	 * @internal	throws IOError An I/O error occurred?
+	 */
+	writeBytes (bytes: ByteArray, offset: number, length: number)
+
+	/**
+	 * Writes an IEEE 754 double-precision (64-bit) floating point number.
+	 * @param	value	A double-precision (64-bit) floating point number.
+	 * @internal	throws IOError An I/O error occurred?
+	 */
+	writeDouble (value: number)
+
+	/**
+	 * Writes an IEEE 754 single-precision (32-bit) floating point number.
+	 * @param	value	A single-precision (32-bit) floating point number.
+	 * @internal	throws IOError An I/O error occurred?
+	 */
+	writeFloat (value: number)
+
+	/**
+	 * Writes a 32-bit signed integer.
+	 * @param	value	A byte value as a signed integer.
+	 * @internal	throws IOError An I/O error occurred?
+	 */
+	writeInt (value: number)
+
+	/**
+	 * Writes a multibyte string to the file stream, byte stream, or byte array, using the specified character set.
+	 * @param	value	The string value to be written.
+	 * @param	charSet	The string denoting the character set to use. Possible character set strings
+	 *   include "shift-jis", "cn-gb", "iso-8859-1", and others.
+	 *   For a complete list, see Supported Character Sets.
+	 */
+	writeMultiByte (value: string, charSet: string)
+
+	/**
+	 * Writes an object to the file stream, byte stream, or byte array, in AMF serialized
+	 * format.
+	 * @param	object	The object to be serialized.
+	 * @internal	throws IOError An I/O error occurred?
+	 */
+	writeObject (object: any)
+
+	/**
+	 * Writes a 16-bit integer. The low 16 bits of the parameter are used;
+	 * the high 16 bits are ignored.
+	 * @param	value	A byte value as an integer.
+	 * @internal	throws IOError An I/O error occurred?
+	 */
+	writeShort (value: number)
+
+	/**
+	 * Writes a 32-bit unsigned integer.
+	 * @param	value	A byte value as an unsigned integer.
+	 * @internal	throws IOError An I/O error occurred?
+	 */
+	writeUnsignedInt (value: number)
+
+	/**
+	 * Writes a UTF-8 string to the file stream, byte stream, or byte array. The length of the UTF-8 string in bytes
+	 * is written first, as a 16-bit integer, followed by the bytes representing the
+	 * characters of the string.
+	 * @param	value	The string value to be written.
+	 * @internal	throws IOError An I/O error occurred?
+	 * @throws	RangeError If the length is larger than
+	 *   65535.
+	 */
+	writeUTF (value: string)
+
+	/**
+	 * Writes a UTF-8 string. Similar to writeUTF(),
+	 * but does not prefix the string with a 16-bit length word.
+	 * @param	value	The string value to be written.
+	 * @internal	throws IOError An I/O error occurred?
+	 */
+	writeUTFBytes (value: string)
+}

package/lib/utils/IExternalizable.ts

@@ -0,0 +1,37 @@
+import { IDataOutput } from './IDataOutput';
+import { IDataInput } from './IDataInput';
+
+/**
+ * The IExternalizable interface provides control over serialization of a class as it is encoded
+ * into a data stream. The <codeph class="+ topic/ph pr-d/codeph ">writeExternal()</codeph> and
+ * <codeph class="+ topic/ph pr-d/codeph ">readExternal()</codeph>
+ * methods of the IExternalizable interface are implemented by a class to allow customization
+ * of the contents and format of the data stream (but not the classname or type) for an object and its supertypes.
+ * Each individual class must serialize and reconstruct the state of its instances.
+ * These methods must be symmetrical with
+ * the supertype to save its state.
+ * These methods supercede the native Action Message Format (AMF) serialization behavior.
+ * <p class="- topic/p ">If a class does not implement, nor inherits from a class which implements,
+ * the IExternalizable interface, then an instance
+ * of the class will be serialized using the default mechanism of public members only.
+ * As a result, private, internal, and
+ * protected members of a class will not be available.</p><p class="- topic/p ">
+ * To serialize private members, a class must use the IExternalizable interface.
+ */
+export interface IExternalizable
+{
+	/**
+	 * A class implements this method to decode itself from a data stream by calling the methods of the IDataInput
+	 * interface. This method must read the values in the same sequence and with the same types as
+	 * were written by the writeExternal() method.
+	 * @param	input	The name of the class that implements the IDataInput interface.
+	 */
+	readExternal (input: IDataInput);
+
+	/**
+	 * A class implements this method to encode itself for a data stream by calling the methods of the IDataOutput
+	 * interface.
+	 * @param	output	The name of the class that implements the IDataOutput interface.
+	 */
+	writeExternal (output: IDataOutput);
+}

package/lib/utils/Timer.ts

@@ -0,0 +1,115 @@
+import { warning } from '@awayfl/swf-loader';
+import { EventDispatcher } from '../events/EventDispatcher';
+import { Errors } from '@awayfl/avm2';
+import { TimerEvent } from '../events/TimerEvent';
+import { SecurityDomain } from '../SecurityDomain';
+
+// Class: Timer
+
+export class Timer extends EventDispatcher {
+	static classInitializer: any = null;
+	static classSymbols: string [] = null; // [];
+	static instanceSymbols: string [] = null;
+
+	/**
+   * This lets you toggle timer event dispatching which is useful when trying to profile other
+   * parts of the system.
+   */
+	public static dispatchingEnabled = true;
+
+	constructor (delay: number, repeatCount: number /*int = 0 */) {
+		super();
+		this._delay = +delay;
+		this._repeatCount = repeatCount | 0;
+		this._iteration = 0;
+	}
+
+	_delay: number;
+	_repeatCount: number /*int*/;
+	_iteration: number /*int*/;
+	_running: boolean;
+	_interval: number;
+
+	get running(): boolean {
+		return this._running;
+	}
+
+	get delay() {
+		return this._delay;
+	}
+
+	set delay(value: number) {
+		value = +value;
+		if (value < 0 || !isFinite(value)) {
+			this.sec.throwError('RangeError', Errors.DelayRangeError);
+		}
+		this._delay = value;
+
+		if (this._running) {
+			this.stop();
+			this.start();
+		}
+	}
+
+	set repeatCount(value: number) {
+		this._repeatCount = value | 0;
+		if (this._repeatCount && this._running && this._iteration >= this._repeatCount) {
+			this.stop();
+		}
+	}
+
+	get repeatCount() {
+		return this._repeatCount;
+	}
+
+	get currentCount(): number {
+		return this._iteration;
+	}
+
+	reset() {
+		if (this._running) {
+			this.stop();
+		}
+		this._iteration = 0;
+	}
+
+	stop(): void {
+		this._running = false;
+		window.clearInterval(this._interval);
+	}
+
+	start(): void {
+		if (this._running) {
+			return;
+		}
+		this._running = true;
+		this._interval = window.setInterval(this._tick.bind(this), this._delay);
+	}
+
+	private _tick(): void {
+		this._iteration++;
+		if (!this._running) {
+			return;
+		}
+		if (Timer.dispatchingEnabled) {
+			//enterTimeline("Timer.Timer");
+			try {
+				this.dispatchEvent(new (<SecurityDomain> this.sec).flash.events.TimerEvent('timer', true, false));
+			} catch (e) {
+				warning('caught error under Timer TIMER event: ', e);
+			}
+			//leaveTimeline();
+		}
+		if (this._repeatCount !== 0 && this._iteration >= this._repeatCount) {
+			this.stop();
+			//enterTimeline("Timer.TimerComplete");
+			try {
+				this.dispatchEvent(
+					new (<SecurityDomain> this.sec).flash.events.TimerEvent(TimerEvent.TIMER_COMPLETE, false, false));
+			} catch (e) {
+				warning('caught error under Timer COMPLETE event: ', e);
+			}
+			//leaveTimeline();
+		}
+	}
+}

package/lib/utils/Trace.ts

@@ -0,0 +1,33 @@
+import { Debug } from '@awayjs/core';
+
+export class Trace extends Object {
+	public static FILE: any;
+	public static LISTENER: any;
+	public static METHODS: number;
+	public static METHODS_AND_LINES: number;
+	public static METHODS_AND_LINES_WITH_ARGS: number;
+	public static METHODS_WITH_ARGS: number;
+	public static OFF: number;
+
+	public static getLevel (target: number = 2): number {
+		// @todo
+		Debug.throwPIR('playerglobals/utils/Trace', 'getLevel', '');
+		return 0;
+	}
+
+	public static getListener (): Function {
+		// @todo
+		Debug.throwPIR('playerglobals/utils/Trace', 'getListener', '');
+		return null;
+	}
+
+	public static setLevel (l: number, target: number = 2): any {
+		// @todo
+		Debug.throwPIR('playerglobals/utils/Trace', 'setLevel', '');
+	}
+
+	public static setListener (f: Function): any {
+		// @todo
+		Debug.throwPIR('playerglobals/utils/Trace', 'setListener', '');
+	}
+}

package/lib/utils/clearInterval.ts

@@ -0,0 +1,8 @@
+/**
+ * Cancels a specified setInterval() call.
+ * @param	id	The ID of the setInterval() call, which you set to a variable,
+ *   as in the following:
+ * @langversion	3.0
+ * @playerversion	Flash 9
+ */
+export const clearInterval = window.clearInterval;

package/lib/utils/clearTimeout.ts

@@ -0,0 +1,8 @@
+/**
+ * Cancels a specified setTimeout() call.
+ * @param	id	The ID of the setTimeout() call, which you set to a variable,
+ *   as in the following:
+ * @langversion	3.0
+ * @playerversion	Flash 9
+ */
+export const clearTimeout = window.clearTimeout;