@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/utils/Timer.js

@@ -0,0 +1,115 @@
+import { __extends } from "tslib";
+import { warning } from '@awayfl/swf-loader';
+import { EventDispatcher } from '../events/EventDispatcher';
+import { Errors } from '@awayfl/avm2';
+import { TimerEvent } from '../events/TimerEvent';
+// Class: Timer
+var Timer = /** @class */ (function (_super) {
+    __extends(Timer, _super);
+    function Timer(delay, repeatCount /*int = 0 */) {
+        var _this = _super.call(this) || this;
+        _this._delay = +delay;
+        _this._repeatCount = repeatCount | 0;
+        _this._iteration = 0;
+        return _this;
+    }
+    Object.defineProperty(Timer.prototype, "running", {
+        get: function () {
+            return this._running;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Timer.prototype, "delay", {
+        get: function () {
+            return this._delay;
+        },
+        set: function (value) {
+            value = +value;
+            if (value < 0 || !isFinite(value)) {
+                this.sec.throwError('RangeError', Errors.DelayRangeError);
+            }
+            this._delay = value;
+            if (this._running) {
+                this.stop();
+                this.start();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Timer.prototype, "repeatCount", {
+        get: function () {
+            return this._repeatCount;
+        },
+        set: function (value) {
+            this._repeatCount = value | 0;
+            if (this._repeatCount && this._running && this._iteration >= this._repeatCount) {
+                this.stop();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Timer.prototype, "currentCount", {
+        get: function () {
+            return this._iteration;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Timer.prototype.reset = function () {
+        if (this._running) {
+            this.stop();
+        }
+        this._iteration = 0;
+    };
+    Timer.prototype.stop = function () {
+        this._running = false;
+        window.clearInterval(this._interval);
+    };
+    Timer.prototype.start = function () {
+        if (this._running) {
+            return;
+        }
+        this._running = true;
+        this._interval = window.setInterval(this._tick.bind(this), this._delay);
+    };
+    Timer.prototype._tick = function () {
+        this._iteration++;
+        if (!this._running) {
+            return;
+        }
+        if (Timer.dispatchingEnabled) {
+            //enterTimeline("Timer.Timer");
+            try {
+                this.dispatchEvent(new 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 this.sec.flash.events.TimerEvent(TimerEvent.TIMER_COMPLETE, false, false));
+            }
+            catch (e) {
+                warning('caught error under Timer COMPLETE event: ', e);
+            }
+            //leaveTimeline();
+        }
+    };
+    Timer.classInitializer = null;
+    Timer.classSymbols = null; // [];
+    Timer.instanceSymbols = null;
+    /**
+   * This lets you toggle timer event dispatching which is useful when trying to profile other
+   * parts of the system.
+   */
+    Timer.dispatchingEnabled = true;
+    return Timer;
+}(EventDispatcher));
+export { Timer };

package/index.ts

@@ -0,0 +1,21 @@
+
+
+console.debug("AwayFL - PlayerGlobal - 0.2.460");
+
+export { Sprite } from './lib/display/Sprite';
+export { MovieClip } from './lib/display/MovieClip';
+export { FlashSceneGraphFactory } from './lib/factories/FlashSceneGraphFactory';
+export { Loader } from './lib/display/Loader';
+export { LoaderInfo } from './lib/display/LoaderInfo';
+export { Stage } from './lib/display/Stage';
+export { LoaderContext } from './lib/system/LoaderContext';
+export { Event } from './lib/events/Event';
+export { URLRequest } from './lib/net/URLRequest';
+export { initLink } from './lib/link';
+
+export { SecurityDomain } from './lib/SecurityDomain';
+export { PlayerGlobal } from './lib/PlayerGlobal';
+
+export { SharedObjectDebug } from './lib/net/SharedObject';
+
+export { DEFAULT_CAPABILITIES } from './lib/system/Capabilities';

package/lib/ILoader.ts

@@ -0,0 +1,14 @@
+import { Stage } from './display/Stage';
+import { DisplayObject } from './display/DisplayObject';
+import { UncaughtErrorEvents } from './events/UncaughtErrorEvents';
+
+export interface ILoader
+{
+	activeStage: Stage;
+
+	stage: Stage;
+
+	content: DisplayObject;
+
+	uncaughtErrorEvents: UncaughtErrorEvents;
+}

package/lib/PlayerGlobal.ts

@@ -0,0 +1,278 @@
+import {
+	ABCFile,
+	ABCCatalog,
+	ActiveLoaderContext,
+	AVM2LoadLibrariesFlags,
+	IPlayerGlobal,
+	AXSecurityDomain,
+	Natives,
+} from '@awayfl/avm2';
+
+import { release, assert, AVMStage, SWFFile } from '@awayfl/swf-loader';
+import { SecurityDomain } from './SecurityDomain';
+import { initLink } from './link';
+import {
+	ISceneGraphFactory,
+	TextField,
+	SceneImage2D,
+	Font,
+	Sprite,
+	MovieClip,
+	MorphSprite,
+	IDisplayObjectAdapter,
+	FrameScriptManager,
+} from '@awayjs/scene';
+
+import { FlashSceneGraphFactory } from './factories/FlashSceneGraphFactory';
+import { AssetBase, Debug, IAsset, WaveAudio } from '@awayjs/core';
+import { ApplicationDomain } from './system/ApplicationDomain';
+import { BitmapImage2D } from '@awayjs/stage';
+import { Graphics } from '@awayjs/graphics';
+import { Stage } from './display/Stage';
+import { DisplayObject } from './display/DisplayObject';
+import { LoaderInfo } from './display/LoaderInfo';
+import { ILoader } from './ILoader';
+import { SharedObject } from './net/SharedObject';
+import { UncaughtErrorEvents } from './events/UncaughtErrorEvents';
+
+// alternate of using a `node path`
+function normalisePath (p: string) {
+	// maybe http:// or https:// etc, like file://
+	const methodIdx = p.indexOf('://');
+	const prepend = p[0] === '/' ? '/'  : '';
+	const parts = p.split(/[\\|/]/).filter(Boolean);
+
+	// when remove '//' from method / will be removed. Restore it
+	if (methodIdx > -1)
+		parts[0] += '/';
+
+	return prepend + parts.join('/');
+}
+
+function browserLoader(url: string, type: 'json' | 'arraybuffer'): Promise<any> {
+	return fetch(normalisePath(url))
+		.then((r) => {
+			if (!r.ok) {
+				throw `Ups: ${r.statusText}(${r.status})`;
+			}
+
+			return type === 'json' ? r.json() : r.arrayBuffer();
+		})
+		.catch(e => {
+			throw new Error('Unable to load: ' + url + ': ' + e);
+		});
+}
+
+export class PlayerGlobal implements IPlayerGlobal, ILoader {
+	public static builtinsBaseUrl = './assets/builtins/';
+	private _contentLoaderInfo: LoaderInfo;
+	private _content: DisplayObject;
+	private _uncaughtErrorEvents: UncaughtErrorEvents;
+	private _avmStage: AVMStage;
+	private _stage: Stage;
+	private _applicationDomain: ApplicationDomain;
+
+	public get activeStage(): Stage {
+		return this._stage;
+	}
+
+	public get stage(): Stage {
+		return this._stage;
+	}
+
+	public get content(): DisplayObject {
+		return this._content;
+	}
+
+	public get uncaughtErrorEvents(): UncaughtErrorEvents {
+		// @todo
+		Debug.throwPIR('playerglobals/display/Loader', 'get uncaughtErrorEvents', '');
+
+		return this._uncaughtErrorEvents;
+	}
+
+	public dispose() {
+		console.log('dispose PlayerGlobal');
+		ApplicationDomain.currentDomain = null;
+		SharedObject._sharedObjects = {};
+	}
+
+	public createSecurityDomain(
+		avmStage: AVMStage,
+		swfFile: SWFFile,
+		libraries: AVM2LoadLibrariesFlags
+	): Promise<ISceneGraphFactory> {
+		this._avmStage = avmStage;
+
+		if (this._avmStage.avmTestHandler) {
+			Natives.print = function (_sec: AXSecurityDomain, _expression: any) {
+				let message = '';
+
+				if (arguments.length == 2) {
+					// eslint-disable-next-line prefer-rest-params
+					message = arguments[1]?.toString();
+				} else {
+					for (let i = 1; i < arguments.length; i++) {
+						// eslint-disable-next-line prefer-rest-params
+						message += arguments[i]?.toString();
+						if (i !== arguments.length - 1) {
+							message += ' ';
+						}
+					}
+				}
+
+				const messageSplit = message.split('\n');
+				for (let i = 0; i < messageSplit.length; i++) {
+					console.log('%c Test-Trace from SWF:', 'color: DodgerBlue', messageSplit[i]);
+					avmStage.avmTestHandler.addMessage(messageSplit[i]);
+				}
+			};
+		}
+
+		initLink();
+
+		release || console.log('createSecurityDomain');
+		release || assert(!!(libraries & AVM2LoadLibrariesFlags.Builtin));
+		release || console.log('Load builtin.abc file');
+
+		const base = PlayerGlobal.builtinsBaseUrl;
+
+		const tasks = [
+			browserLoader(`${base}/builtin.abc`, 'arraybuffer')
+		];
+
+		if (libraries & AVM2LoadLibrariesFlags.Playerglobal) {
+			tasks.push(
+				browserLoader(`${base}/playerglobal.abcs`,'arraybuffer'),
+				browserLoader(`${base}/playerglobal.json`, 'json'),
+				browserLoader(`${base}/avmplus.abc`, 'arraybuffer')
+			);
+		}
+
+		return Promise.all(tasks).then(([builtins, pgByte, pgJson, avmplus]) => {
+			const sec = new SecurityDomain();
+			const builtinABC = new ABCFile({
+				url: 'builtin.abc',
+				app: sec.system
+			}, new Uint8Array(builtins));
+
+			(<any>sec).swfVersion = swfFile.swfVersion;
+			sec.system.loadABC(builtinABC);
+			sec.initialize();
+			sec.system.executeABC(builtinABC);
+			sec.player = avmStage;
+
+			if (!(libraries & AVM2LoadLibrariesFlags.Playerglobal)) {
+				return null;
+			}
+
+			release || console.log('Load playerglobal.abcs & playerglobal.json');
+			const catalog = new ABCCatalog(sec.system, new Uint8Array(pgByte), pgJson);
+
+			release || console.log('add playerglobals as ABCCatalog');
+			sec.addCatalog(catalog);
+
+			const avmPlusABC = new ABCFile({
+				url: 'avmplus.File',
+				app: sec.system
+			}, new Uint8Array(avmplus));
+
+			sec.system.loadAndExecuteABC(avmPlusABC);
+
+			this._constructStage(sec, swfFile);
+
+			return new FlashSceneGraphFactory(sec);
+		});
+	}
+
+	private _constructStage(sec: SecurityDomain, file: SWFFile) {
+		this._contentLoaderInfo = new sec.flash.display.LoaderInfo(this, this._avmStage.root);
+		this._contentLoaderInfo.url = new URL(file.url, document.baseURI).href;
+		this._contentLoaderInfo._setFlashVars(this._avmStage.config?.flashvars);
+		this._applicationDomain = new sec.flash.system.ApplicationDomain();
+		this._contentLoaderInfo._setApplicationDomain(this._applicationDomain);
+		this._uncaughtErrorEvents = new sec.flash.events.UncaughtErrorEvents();
+
+		// not needs, because shuld be resolved from domain
+		ActiveLoaderContext.loaderContext = new sec.flash.system.LoaderContext(
+			false,
+			this._applicationDomain
+		);
+
+		this._stage = new sec.flash.display.Stage();
+		sec.flash.display.DisplayObject.axClass._activeStage = this._stage;
+		this._avmStage.root.adapter = this._stage;
+		this._stage.adaptee = this._avmStage.root;
+	}
+
+	public enterFrame() {
+		this._stage && this._stage.enterFrame();
+	}
+
+	public resizeStage() {
+		// it can happen that resizeStage is called before createSecurityDomain has finished and stage exists
+		this._stage && this._stage.resizeCallback();
+	}
+
+	public addAsset(asset: IAsset, addScene: boolean) {
+		(<any>asset.adapter).loaderInfo = this._contentLoaderInfo;
+		switch (asset.assetType) {
+			case TextField.assetType: {
+				this._applicationDomain.addDefinition(asset.name, <TextField>asset);
+				break;
+			}
+			case SceneImage2D.assetType:
+			case BitmapImage2D.assetType: {
+				this._applicationDomain.addDefinition(asset.name, <SceneImage2D>asset);
+				break;
+				// we should only do this for bitmaps loaded from jpg or png
+				// todo:
+				//if (this._isImage)
+				//	(<AwayDisplayObjectContainer> this._adaptee).addChild(
+				//	new Bitmap(<BitmapData> (<SceneImage2D> asset).adapter).adaptee);
+			}
+			case WaveAudio.assetType: {
+				this._applicationDomain.addAudioDefinition(asset.name, <WaveAudio>asset);
+				break;
+			}
+			case Font.assetType: {
+				this._applicationDomain.addFontDefinition(asset.name, <Font>asset);
+				break;
+			}
+			case Sprite.assetType: {
+				this._applicationDomain.addDefinition(asset.name, <Sprite>asset);
+				break;
+			}
+			case MovieClip.assetType: {
+				this._applicationDomain.addDefinition(asset.name, <MovieClip>asset);
+
+				// if this is the "Scene 1", we make it a child of the loader
+				if (addScene && (<any>asset).isAVMScene) {
+					// "Scene 1" when AWDParser, isAVMScene when using SWFParser
+
+					this._content = <DisplayObject>(<IDisplayObjectAdapter>asset.adapter).clone();
+					this._content.loaderInfo = this._contentLoaderInfo;
+					this._content.adaptee.reset();
+					(<any> this._content.adaptee).firstFrameOnSWFStart = true;
+					FrameScriptManager.invalidAS3Constructors = true;
+					(<any> this._stage.adaptee).addChild(this._content.adaptee);
+					FrameScriptManager.execute_as3_constructors_recursiv(<any> this._content.adaptee);
+					this._content.dispatchStaticEvent('added', this._content);
+					this._content.dispatch_ADDED_TO_STAGE(true);
+				}
+				break;
+			}
+			case '[asset Generic]': {
+				this._applicationDomain.addDefinition(asset.name, asset as AssetBase);
+				break;
+			}
+			case Graphics.assetType:
+			case MorphSprite.assetType: {
+				break;
+			}
+			default: {
+				console.warn('Loaded unhandled asset-type', asset.assetType);
+			}
+		}
+	}
+}

package/lib/RegisterCode.ts

@@ -0,0 +1,10 @@
+export class RegisterCode {}
+
+import { TextureAtlasParser, ImageCubeParser, Image2DParser } from '@awayjs/stage';
+import { Loader, WaveAudioParser } from '@awayjs/core';
+
+//enable parsers
+Loader.enableParser(WaveAudioParser);
+Loader.enableParser(Image2DParser);
+Loader.enableParser(ImageCubeParser);
+Loader.enableParser(TextureAtlasParser);

package/lib/SecurityDomain.ts

@@ -0,0 +1,194 @@
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { EventDispatcher } from './events/EventDispatcher';
+import { DisplayObject } from './display/DisplayObject';
+import { DisplayObjectContainer } from './display/DisplayObjectContainer';
+import { Stage } from './display/Stage';
+import { Loader } from './display/Loader';
+import { LoaderInfo } from './display/LoaderInfo';
+import { MovieClip } from './display/MovieClip';
+import { Graphics } from './display/Graphics';
+import { GraphicsPath } from './display/GraphicsPath';
+import { GraphicsSolidFill } from './display/GraphicsSolidFill';
+import { GraphicsEndFill } from './display/GraphicsEndFill';
+import { GraphicsGradientFill } from './display/GraphicsGradientFill';
+import { GraphicsBitmapFill } from './display/GraphicsBitmapFill';
+import { GraphicsStroke } from './display/GraphicsStroke';
+import { GraphicsTrianglePath } from './display/GraphicsTrianglePath';
+import { Bitmap } from './display/Bitmap';
+import { BitmapData } from './display/BitmapData';
+import { SimpleButton } from './display/SimpleButton';
+import { TextField } from './text/TextField';
+import { Point } from './geom/Point';
+import { Event } from './events/Event';
+import { KeyboardEvent } from './events/KeyboardEvent';
+import { MouseEvent } from './events/MouseEvent';
+import { TouchEvent } from './events/TouchEvent';
+import { ProgressEvent } from './events/ProgressEvent';
+import { Rectangle } from './geom/Rectangle';
+import { Matrix } from './geom/Matrix';
+import { ColorTransform } from './geom/ColorTransform';
+import { Transform } from './geom/Transform';
+import { URLRequest } from './net/URLRequest';
+import { URLLoader } from './net/URLLoader';
+import { URLVariables } from './net/URLVariables';
+import { SharedObject } from './net/SharedObject';
+import { LoaderContext } from './system/LoaderContext';
+import { Sound } from './media/Sound';
+import { TextFormat } from './text/TextFormat';
+import { AXSecurityDomain, ByteArray, XMLNode } from '@awayfl/avm2';
+import { Sprite } from './display/Sprite';
+import { ApplicationDomain } from './system/ApplicationDomain';
+import { TextSnapshot } from './text/TextSnapshot';
+import { ExternalInterface } from './external/ExternalInterface';
+import { Capabilities } from './system/Capabilities';
+import { Security } from './system/Security';
+import { fscommand } from './system/FSCommand';
+import { SoundChannel } from './media/SoundChannel';
+import { SoundTransform } from './media/SoundTransform';
+import { SoundMixer } from './media/SoundMixer';
+import { IOErrorEvent } from './events/IOErrorEvent';
+import { Vector3D } from './geom/Vector3D';
+import { Matrix3D } from './geom/Matrix3D';
+import { Shape } from './display/Shape';
+import { TimerEvent } from './events/TimerEvent';
+import { GlowFilter } from './filters/GlowFilter';
+import { BevelFilter } from './filters/BevelFilter';
+import { BitmapFilter } from './filters/BitmapFilter';
+import { BlurFilter } from './filters/BlurFilter';
+import { ColorMatrixFilter } from './filters/ColorMatrixFilter';
+import { ConvolutionFilter } from './filters/ConvolutionFilter';
+import { DisplacementMapFilter } from './filters/DisplacementMapFilter';
+import { DropShadowFilter } from './filters/DropShadowFilter';
+import { GradientBevelFilter } from './filters/GradientBevelFilter';
+import { GradientGlowFilter } from './filters/GradientGlowFilter';
+import { ContextMenuBuiltInItems } from './ui/ContextMenuBuiltInItems';
+import { ContextMenu } from './ui/ContextMenu';
+import { ContextMenuItem } from './ui/ContextMenuItem';
+import { FrameLabel } from './display/FrameLabel';
+import { TextLineMetrics } from './text/TextLineMetrics';
+import { FocusEvent } from './events/FocusEvent';
+import { UncaughtErrorEvents } from './events/UncaughtErrorEvents';
+import { NetConnection } from './net/NetConnection';
+import { Responder } from './net/Responder';
+
+export class Mouse {}
+
+export class SecurityDomain extends AXSecurityDomain {
+	public flash = {
+		display: {
+			EventDispatcher: EventDispatcher,
+			DisplayObject: DisplayObject,
+			DisplayObjectContainer: DisplayObjectContainer,
+			Stage: Stage,
+			Loader: Loader,
+			LoaderInfo: LoaderInfo,
+			MovieClip: MovieClip,
+			Graphics: Graphics,
+			GraphicsPath: GraphicsPath,
+			GraphicsSolidFill: GraphicsSolidFill,
+			GraphicsEndFill: GraphicsEndFill,
+			GraphicsGradientFill: GraphicsGradientFill,
+			GraphicsBitmapFill: GraphicsBitmapFill,
+			GraphicsStroke: GraphicsStroke,
+			GraphicsTrianglePath: GraphicsTrianglePath,
+			Bitmap: Bitmap,
+			BitmapData: BitmapData,
+			SimpleButton: SimpleButton,
+			Sprite: Sprite,
+			Shape: Shape,
+			FrameLabel: FrameLabel
+		},
+		events: {
+			EventDispatcher: EventDispatcher,
+			Event: Event,
+			FocusEvent: FocusEvent,
+			KeyboardEvent: KeyboardEvent,
+			MouseEvent: MouseEvent,
+			TouchEvent: TouchEvent,
+			ProgressEvent: ProgressEvent,
+			IOErrorEvent: IOErrorEvent,
+			TimerEvent:TimerEvent,
+			UncaughtErrorEvents: UncaughtErrorEvents,
+		},
+		external: {
+			ExternalInterface: ExternalInterface
+		},
+		filters: {
+			BevelFilter: BevelFilter,
+			BitmapFilter: BitmapFilter,
+			BlurFilter: BlurFilter,
+			ColorMatrixFilter: ColorMatrixFilter,
+			ConvolutionFilter: ConvolutionFilter,
+			DisplacementMapFilter: DisplacementMapFilter,
+			DropShadowFilter: DropShadowFilter,
+			GlowFilter: GlowFilter,
+			GradientBevelFilter: GradientBevelFilter,
+			GradientGlowFilter: GradientGlowFilter,
+		},
+		text: {
+			TextField: TextField,
+			TextFormat: TextFormat,
+			TextSnapshot: TextSnapshot,
+			TextLineMetrics: TextLineMetrics,
+		},
+		geom: {
+			Point: Point,
+			Rectangle: Rectangle,
+			Matrix: Matrix,
+			ColorTransform: ColorTransform,
+			Transform: Transform,
+			Vector3D: Vector3D,
+			Matrix3D: Matrix3D
+		},
+		net: {
+			URLRequest: URLRequest,
+			URLLoader: URLLoader,
+			URLVariables: URLVariables,
+			SharedObject: SharedObject,
+			NetConnection: NetConnection,
+			Responder: Responder
+		},
+		system: {
+			ApplicationDomain: ApplicationDomain,
+			Capabilities: Capabilities,
+			LoaderContext: LoaderContext,
+			Security: Security,
+			fscommand: fscommand
+		},
+		ui: {
+			ContextMenu: ContextMenu,
+			ContextMenuItem: ContextMenuItem,
+			ContextMenuBuiltInItems: ContextMenuBuiltInItems,
+			Mouse: Mouse
+		},
+		utils: {
+			ByteArray: ByteArray
+		},
+		media: {
+			Sound: Sound,
+			SoundChannel: SoundChannel,
+			SoundTransform: SoundTransform,
+			SoundMixer: SoundMixer
+		},
+		xml: {
+			XMLDocument: XMLDocument,
+			XMLNode: XMLNode
+		}
+	};
+	//public player: any;//80pro Shumway.Player.Player;
+	//public application: AXApplicationDomain;
+}

package/lib/Settings.ts

@@ -0,0 +1,15 @@
+import { ConfigManager }  from '@awayjs/core';
+
+export interface IPlayerGlobalSettings {
+
+	ENABLE_FILE_PICKER: boolean;
+}
+
+export const Settings: IPlayerGlobalSettings = ConfigManager.instance.addStore<any>('playerglobal',{
+
+	/**
+	 * @description Enable experimental File Picker
+	 */
+	ENABLE_FILE_PICKER: true,
+
+});

package/lib/_shumway_flash/accessibility/Accessibility.ts

@@ -0,0 +1,40 @@
+import { ASObject } from '@awayfl/avm2';
+import { DisplayObject } from '../display/DisplayObject';
+
+export class Accessibility extends ASObject {
+
+	// Called whenever the class is initialized.
+	public static classInitializer: any = null;
+
+	// List of static symbols to link.
+	public static classSymbols: string [] = null; // [];
+
+	// List of instance symbols to link.
+	public static instanceSymbols: string [] = null; // [];
+
+	constructor () {
+		super();
+	}
+
+	// JS -> AS Bindings
+
+	// AS -> JS Bindings
+	private static _active: boolean = false;
+
+	public static get active(): boolean {
+		return Accessibility._active;
+	}
+
+	public static sendEvent(
+		source: DisplayObject,
+		childID: number /*uint*/,
+		eventType: number /*uint*/,
+		nonHTML: boolean = false): void {
+		console.warn('[Accessibility] - sendEvent not implemented');
+	}
+
+	public static updateProperties(): void {
+		console.warn('[Accessibility] - updateProperties not implemented');
+	}
+
+}