@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/display/LoaderInfo.js

@@ -0,0 +1,765 @@
+import { __extends } from "tslib";
+import { EventDispatcher } from '../events/EventDispatcher';
+import { ApplicationDomain } from '../system/ApplicationDomain';
+import { IOErrorEvent } from '../events/IOErrorEvent';
+import { ProgressEvent } from '../events/ProgressEvent';
+import { Event } from '../events/Event';
+import { Loader } from './Loader';
+import { URLLoaderEvent, LoaderEvent as AwayLoaderEvent, Debug } from '@awayjs/core';
+import { PickGroup } from '@awayjs/view';
+import { AVMStage } from '@awayfl/swf-loader';
+function parseQueryString(url) {
+    var result = {};
+    var index = url ? url.indexOf('?') : -1;
+    if (index === -1) {
+        return result;
+    }
+    new URLSearchParams(url.substring(index + 1).split('#')[0]).forEach(function (value, key) {
+        result[key] = value;
+    });
+    return result;
+}
+var LoaderInfoCompleteQueue = /** @class */ (function () {
+    function LoaderInfoCompleteQueue() {
+    }
+    LoaderInfoCompleteQueue.addQueue = function (LoaderInfo) {
+        this._queue.push({
+            loaderInfo: LoaderInfo,
+            delayCnt: this.DELAY
+        });
+    };
+    LoaderInfoCompleteQueue.executeQueue = function () {
+        var queue = this._queue;
+        var i = queue.length;
+        var allDone = true;
+        while (i > 0) {
+            i--;
+            var loderInfoItem = queue[i];
+            loderInfoItem.delayCnt--;
+            if (loderInfoItem.delayCnt > 0) {
+                allDone = false;
+            }
+            else if (loderInfoItem.delayCnt == 0) {
+                var newEvent = new loderInfoItem.loaderInfo.sec.flash.events.Event(Event.COMPLETE);
+                newEvent.currentTarget = loderInfoItem.loaderInfo;
+                loderInfoItem.loaderInfo.dispatchEvent(newEvent);
+            }
+        }
+        if (allDone)
+            queue.length = 0;
+    };
+    LoaderInfoCompleteQueue._queue = [];
+    LoaderInfoCompleteQueue.DELAY = 2;
+    return LoaderInfoCompleteQueue;
+}());
+export { LoaderInfoCompleteQueue };
+/**
+ * The LoaderInfo export class provides information about a loaded SWF file or a
+ * loaded image file(JPEG, GIF, or PNG). LoaderInfo objects are available for
+ * any display object. The information provided includes load progress, the
+ * URLs of the loader and loaded content, the number of bytes total for the
+ * media, and the nominal height and width of the media.
+ *
+ * You can access LoaderInfo objects in two ways:
+ *
+ * * The `contentLoaderInfo` property of a flash.display.Loader
+ *   object -  The `contentLoaderInfo` property is always available
+ *   for any Loader object. For a Loader object that has not called the
+ *   `load()` or `loadBytes()` method, or that has not
+ *   sufficiently loaded, attempting to access many of the properties of the
+ *   `contentLoaderInfo` property throws an error.
+ * * The `loaderInfo` property of a display object.
+ *
+ * The `contentLoaderInfo` property of a Loader object provides
+ * information about the content that the Loader object is loading, whereas
+ * the `loaderInfo` property of a DisplayObject provides
+ * information about the root SWF file for that display object.
+ *
+ * When you use a Loader object to load a display object(such as a SWF
+ * file or a bitmap), the `loaderInfo` property of the display
+ * object is the same as the `contentLoaderInfo` property of the
+ * Loader object(`DisplayObject.loaderInfo =
+ * Loader.contentLoaderInfo`). Because the instance of the main export class of
+ * the SWF file has no Loader object, the `loaderInfo` property is
+ * the only way to access the LoaderInfo for the instance of the main export class of
+ * the SWF file.
+ *
+ * The following diagram shows the different uses of the LoaderInfo
+ * object - for the instance of the main export class of the SWF file, for the
+ * `contentLoaderInfo` property of a Loader object, and for the
+ * `loaderInfo` property of a loaded object:
+ *
+ * When a loading operation is not complete, some properties of the
+ * `contentLoaderInfo` property of a Loader object are not
+ * available. You can obtain some properties, such as
+ * `bytesLoaded`, `bytesTotal`, `url`,
+ * `loaderURL`, and `applicationDomain`. When the
+ * `loaderInfo` object dispatches the `init` event, you
+ * can access all properties of the `loaderInfo` object and the
+ * loaded image or SWF file.
+ *
+ * **Note:** All properties of LoaderInfo objects are read-only.
+ *
+ * The `EventDispatcher.dispatchEvent()` method is not
+ * applicable to LoaderInfo objects. If you call `dispatchEvent()`
+ * on a LoaderInfo object, an IllegalOperationError exception is thrown.
+ *
+ * @event complete   Dispatched when data has loaded successfully. In other
+ *                   words, it is dispatched when all the content has been
+ *                   downloaded and the loading has finished. The
+ *                   `complete` event is always dispatched after
+ *                   the `init` event. The `init` event
+ *                   is dispatched when the object is ready to access, though
+ *                   the content may still be downloading.
+ * @event httpStatus Dispatched when a network request is made over HTTP and
+ *                   an HTTP status code can be detected.
+ * @event init       Dispatched when the properties and methods of a loaded
+ *                   SWF file are accessible and ready for use. The content,
+ *                   however, can still be downloading. A LoaderInfo object
+ *                   dispatches the `init` event when the following
+ *                   conditions exist:
+ *
+ *                   * All properties and methods associated with the
+ *                     loaded object and those associated with the LoaderInfo
+ *                     object are accessible.
+ *                   * The constructors for all child objects have
+ *                     completed.
+ *                   * All ActionScript code in the first frame of the
+ *                     loaded SWF's main timeline has been executed.
+ *
+ *                   For example, an `Event.INIT` is dispatched
+ *                   when the first frame of a movie or animation is loaded.
+ *                   The movie is then accessible and can be added to the
+ *                   display list. The complete movie, however, can take
+ *                   longer to download. The `Event.COMPLETE` is
+ *                   only dispatched once the full movie is loaded.
+ *
+ *                   The `init` event always precedes the
+ *                   `complete` event.
+ * @event ioError    Dispatched when an input or output error occurs that
+ *                   causes a load operation to fail.
+ * @event open       Dispatched when a load operation starts.
+ * @event progress   Dispatched when data is received as the download
+ *                   operation progresses.
+ * @event unload     Dispatched by a LoaderInfo object whenever a loaded
+ *                   object is removed by using the `unload()`
+ *                   method of the Loader object, or when a second load is
+ *                   performed by the same Loader object and the original
+ *                   content is removed prior to the load beginning.
+ */
+var LoaderInfo = /** @class */ (function (_super) {
+    __extends(LoaderInfo, _super);
+    function LoaderInfo(loader, container) {
+        var _this = _super.call(this) || this;
+        _this._bytesLoaded = 0;
+        _this._bytesTotal = 0;
+        _this._urlParameters = {};
+        _this._flashVars = {};
+        _this._parameters = null;
+        // Events that are supposed to be working are registered as eventMappingExtern:
+        _this.eventMappingExtern[Event.COMPLETE] = 'LoaderInfo:Event.COMPLETE';
+        _this.eventMappingExtern[ProgressEvent.PROGRESS] = 'LoaderInfo:ProgressEvent.PROGRESS';
+        _this.eventMappingExtern[IOErrorEvent.IO_ERROR] = 'LoaderInfo:IOErrorEvent.IO_ERROR';
+        // Events not supported yet are registered as eventMappingDummys:
+        _this.eventMappingDummys[Event.UNLOAD] = 'LoaderInfo:Event.UNLOAD';
+        //this.eventMappingDummys[IOErrorEvent.IO_ERROR]="LoaderInfo:IOErrorEvent.IO_ERROR";
+        //this.eventMappingDummys[HTTPStatusEvent.IO_ERROR]="HTTPStatusEvent.IO_ERROR";
+        _this.eventMappingDummys[Event.OPEN] = 'LoaderInfo:Event.OPEN';
+        _this.eventMappingDummys[Event.INIT] = 'LoaderInfo:Event.INIT';
+        _this._onLoaderStartDelegate = function (event) { return _this._onLoaderStart(event); };
+        _this._onLoadProgressDelegate = function (event) { return _this._onLoadProgress(event); };
+        _this._onLoaderCompleteDelegate = function (event) { return _this._onLoaderComplete(event); };
+        _this._onLoaderErrorDelegate = _this._onLoadeError.bind(_this);
+        _this._loader = loader;
+        _this._container = container;
+        _this._container.addEventListener(AwayLoaderEvent.LOADER_START, _this._onLoaderStartDelegate);
+        _this._container.addEventListener(URLLoaderEvent.LOAD_PROGRESS, _this._onLoadProgressDelegate);
+        _this._container.addEventListener(AwayLoaderEvent.LOADER_COMPLETE, _this._onLoaderCompleteDelegate);
+        _this._container.addEventListener(URLLoaderEvent.LOAD_ERROR, _this._onLoaderErrorDelegate);
+        return _this;
+    }
+    Object.defineProperty(LoaderInfo.prototype, "actionScriptVersion", {
+        /**
+         * The ActionScript version of the loaded SWF file. The language
+         * version is specified by using the enumerations in the
+         * ActionScriptVersion class, such as
+         * `ActionScriptVersion.ACTIONSCRIPT2` and `ActionScriptVersion.ACTIONSCRIPT3`.
+         *
+         * **Note:** This property always has a value of either
+         * `ActionScriptVersion.ACTIONSCRIPT2` or `ActionScriptVersion.ACTIONSCRIPT3`.
+         * ActionScript 1.0 and 2.0 are both reported as
+         * `ActionScriptVersion.ACTIONSCRIPT2` (version 2.0). This property only
+         * distinguishes ActionScript 1.0 and 2.0 from ActionScript 3.0.
+         *
+         * @throws	Error If the file is not downloaded sufficiently to retrieve the
+         *                requested information.
+         * @throws	Error If the file is not a SWF file.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/LoaderInfo', 'get actionScriptVersion', '');
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "source", {
+        set: function (value) {
+            this._source = value;
+            this._bytesTotal = (value === null || value === void 0 ? void 0 : value.length) || 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    // for AVM:
+    LoaderInfo.prototype.getSymbolById = function (value) { };
+    LoaderInfo.prototype._onLoadeError = function (event) {
+        var newEvent = new this.sec.flash.events.IOErrorEvent(IOErrorEvent.IO_ERROR);
+        newEvent.currentTarget = this;
+        this.dispatchEvent(newEvent);
+    };
+    LoaderInfo.prototype._onLoaderStart = function (event) {
+        var _a;
+        this._bytesLoaded = 0;
+        this._bytesTotal = ((_a = this._source) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        this._setURL(new URL(event.url, document.baseURI).href);
+    };
+    LoaderInfo.prototype._setURL = function (value) {
+        this._url = value;
+        // read now, as the url getter strips the query string
+        this._urlParameters = parseQueryString(value);
+        this._parameters = null;
+    };
+    /**
+     * Sets the FlashVars passed to the main SWF file by the embedding page
+     */
+    LoaderInfo.prototype._setFlashVars = function (value) {
+        this._flashVars = {};
+        for (var key in value) {
+            this._flashVars[key] = String(value[key]);
+        }
+        this._parameters = null;
+    };
+    LoaderInfo.prototype._onLoadProgress = function (event) {
+        this._bytesLoaded = event.urlLoader.bytesLoaded;
+        this._bytesTotal = event.urlLoader.bytesTotal;
+        var newEvent = new this.sec.flash.events.ProgressEvent(ProgressEvent.PROGRESS, null, null, event.urlLoader.bytesLoaded, event.urlLoader.bytesTotal);
+        newEvent.currentTarget = this;
+        this.dispatchEvent(newEvent);
+    };
+    LoaderInfo.prototype._onLoaderComplete = function (event) {
+        if (this._source) {
+            this._bytesTotal = this._bytesLoaded = this._source.length;
+        }
+        else if (event.assets && event.assets.length) {
+            // use count of assets instead real bytes
+            this._bytesLoaded = event.assets.length;
+            this._bytesTotal = event.assets.length;
+        }
+        else {
+            this._bytesTotal = this._bytesLoaded = this._bytesTotal || 1; //avoid devide on 0
+        }
+        this._url = new URL(event.url, document.baseURI).href;
+        LoaderInfoCompleteQueue.addQueue(this);
+    };
+    Object.defineProperty(LoaderInfo.prototype, "applicationDomain", {
+        /**
+         * When an external SWF file is loaded, all ActionScript 3.0 definitions
+         * contained in the loaded class are stored in the
+         * `applicationDomain` property.
+         *
+         * All code in a SWF file is defined to exist in an application domain.
+         * The current application domain is where your main application runs. The
+         * system domain contains all application domains, including the current
+         * domain and all classes used by Flash Player or Adobe AIR.
+         *
+         * All application domains, except the system domain, have an associated
+         * parent domain. The parent domain of your main application's
+         * `applicationDomain` is the system domain. Loaded classes are
+         * defined only when their parent doesn't already define them. You cannot
+         * override a loaded class definition with a newer definition.
+         *
+         * For usage examples of application domains, see the "Client System
+         * Environment" chapter in the _ActionScript 3.0 Developer's Guide_.
+         *
+         * @throws SecurityError This security sandbox of the caller is not allowed
+         *                       to access this ApplicationDomain.
+         */
+        get: function () {
+            return this._applicationDomain;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "bytes", {
+        /**
+         * The bytes associated with a LoaderInfo object.
+         *
+         * @throws SecurityError If the object accessing this API is prevented from
+         *                       accessing the loaded object due to security
+         *                       restrictions. This situation can occur, for
+         *                       instance, when a Loader object attempts to access
+         *                       the `contentLoaderInfo.content` property
+         *                       and it is not granted security permission to access
+         *                       the loaded content.
+         *
+         *                       For more information related to security, see the
+         *                       Flash Player Developer Center Topic:
+         *                       [Security](http://www.adobe.com/go/devnet_security_en).
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/LoaderInfo', 'get bytes', '');
+            return null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "bytesLoaded", {
+        /**
+         * The number of bytes that are loaded for the media. When this number equals
+         * the value of `bytesTotal`, all of the bytes are loaded.
+         */
+        get: function () {
+            return this._bytesLoaded;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "bytesTotal", {
+        /**
+         * The number of compressed bytes in the entire media file.
+         *
+         * Before the first `progress` event is dispatched by this
+         * LoaderInfo object's corresponding Loader object, `bytesTotal`
+         * is 0. After the first `progress` event from the Loader object,
+         * `bytesTotal` reflects the actual number of bytes to be
+         * downloaded.
+         */
+        get: function () {
+            return this._bytesTotal;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "childAllowsParent", {
+        /**
+         * Expresses the trust relationship from content (child) to the Loader (parent).
+         * If the child has allowed the parent access, true; otherwise, false. This
+         * property is set to true if the child object has called the `allowDomain()`
+         * method to grant permission to the parent domain or if a URL policy is loaded
+         * at the child domain that grants permission to the parent domain. If child
+         * and parent are in the same domain, this property is set to true.
+         *
+         * For more information related to security, see the Flash Player Developer
+         * Center Topic: [Security](http://www.adobe.com/go/devnet_security_en).
+         *
+         * @throws Error Thrown if the file is not downloaded sufficiently to retrieve
+         *               the requested information.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/LoaderInfo', 'get childAllowsParent', '');
+            return false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "childSandboxBridge", {
+        /**
+         * A object that can be set by the loaded content's code to expose properties
+         * and methods that can be accessed  by code in the Loader object's sandbox.
+         * This _sandbox bridge_ lets content from a non-application domain have
+         * controlled access to scripts in the AIR application sandbox, and vice versa.
+         * The sandbox bridge serves as a gateway between the sandboxes, providing
+         * explicit interaction between application and non-application security
+         * sandboxes.
+         *
+         * @throws SecurityError Only content in the loaded content's sandbox can set
+         *                       this property.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/LoaderInfo', 'get childSandboxBridge', '');
+            return null;
+        },
+        set: function (door) {
+            // @todo
+            Debug.throwPIR('playerglobals/display/LoaderInfo', 'set childSandboxBridge', '');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "content", {
+        /**
+         * The loaded object associated with this LoaderInfo object.
+         *
+         * @throws SecurityError If the object accessing this API is prevented from
+         *                       accessing the loaded object due to security
+         *                       restrictions. This situation can occur, for
+         *                       instance, when a Loader object attempts to access
+         *                       the `contentLoaderInfo.content` property
+         *                       and it is not granted security permission to access
+         *                       the loaded content.
+         *
+         *                       For more information related to security, see the
+         *                       Flash Player Developer Center Topic:
+         *                       [Security](http://www.adobe.com/go/devnet_security_en).
+         */
+        get: function () {
+            return this._loader.content;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "contentType", {
+        /**
+         * The MIME type of the loaded file. The value is `null` if not
+         * enough of the file has loaded in order to determine the type. The
+         * following list gives the possible values:
+         *
+         * * `"application/x-shockwave-flash"`
+         * * `"image/jpeg"`
+         * * `"image/gif"`
+         * * `"image/png"`
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/LoaderInfo', 'get contentType', '');
+            return null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "frameRate", {
+        /**
+         * The nominal frame rate, in frames per second, of the loaded SWF file. This
+         * number is often an integer, but need not be.
+         *
+         * This value may differ from the actual frame rate in use. Flash Player
+         * or Adobe AIR only uses a single frame rate for all loaded SWF files at any
+         * one time, and this frame rate is determined by the nominal frame rate of
+         * the main SWF file. Also, the main frame rate may not be able to be
+         * achieved, depending on hardware, sound synchronization, and other
+         * factors.
+         *
+         * @throws Error If the file is not downloaded sufficiently to retrieve the
+         *               requested information.
+         * @throws Error If the file is not a SWF file.
+         */
+        get: function () {
+            return AVMStage.instance().frameRate;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "height", {
+        /**
+         * The nominal height of the loaded file. This value might differ from the
+         * actual height at which the content is displayed, since the loaded content
+         * or its parent display objects might be scaled.
+         *
+         * @throws Error If the file is not downloaded sufficiently to retrieve the
+         *               requested information.
+         */
+        get: function () {
+            var node = AVMStage.instance().view.getNode(this._container);
+            var box = PickGroup.getInstance().getBoundsPicker(node).getBoxBounds(node);
+            return (box == null) ? 0 : box.height;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "isURLInaccessible", {
+        /**
+         * Indicates if the `LoaderInfo.url` property has been truncated.
+         *
+         * When the `isURLInaccessible` value is true the `LoaderInfo.url` value is only
+         * the domain of the final URL from which the content loaded. For example, the
+         * property is truncated if the content is loaded from
+         * `http://www.adobe.com/assets/hello.swf`, and the `LoaderInfo.url` property
+         * has the value `http://www.adobe.com`. The `isURLInaccessible`
+         * value is true only when all of the following are also true:
+         *
+         * * An HTTP redirect occurred while loading the content.
+         * * The SWF file calling `Loader.load()` is from a different domain than the
+         *   content's final URL.
+         * * The SWF file calling `Loader.load()` does not have permission to access
+         *   the content. Permission is granted to access the content the same way
+         *   permission is granted for `BitmapData.draw()`: call `Security.allowDomain()`
+         *   to access a SWF file (or for non-SWF file content, establish a policy
+         *   file and use the `LoaderContext.checkPolicyFile` property).
+         *
+         * **Note:** The `isURLInaccessible` property was added for Flash Player 10.1 and
+         * AIR 2.0. However, this property is made available to SWF files of all
+         * versions when the Flash runtime supports it. So, using some authoring tools
+         * in "strict mode" causes a compilation error. To work around the error use
+         * the indirect syntax `myLoaderInfo["isURLInaccessible"]`, or disable strict
+         * mode. If you are using Flash Professional CS5 or Flex SDK 4.1, you can use
+         * and compile this API for runtimes released before Flash Player 10.1 and AIR 2.
+         *
+         * For application content in AIR, the value of this property is always false.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/LoaderInfo', 'get isURLInaccessible', '');
+            return false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "loader", {
+        /**
+         * The Loader object associated with this LoaderInfo object. If this
+         * LoaderInfo object is the `loaderInfo` property of the instance
+         * of the main export class of the SWF file, no Loader object is associated.
+         *
+         * @throws SecurityError If the object accessing this API is prevented from
+         *                       accessing the Loader object because of security
+         *                       restrictions. This can occur, for instance, when a
+         *                       loaded SWF file attempts to access its
+         *                       `loaderInfo.loader` property and it is
+         *                       not granted security permission to access the
+         *                       loading SWF file.
+         *
+         *                       For more information related to security, see the
+         *                       Flash Player Developer Center Topic:
+         *                       [Security](http://www.adobe.com/go/devnet_security_en).
+         */
+        get: function () {
+            return (this._loader instanceof Loader) ? this._loader : null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "loaderURL", {
+        /**
+         * The URL of the SWF file that initiated the loading of the media described
+         * by this LoaderInfo object. For the instance of the main class of the SWF
+         * file, this URL is the same as the SWF file's own URL.
+         */
+        get: function () {
+            return this._loader.activeStage.getChildAt(0).loaderInfo.url;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "parameters", {
+        /**
+         * An object that contains name-value pairs that represent the parameters
+         * provided to the loaded SWF file.
+         *
+         * You can use a `for-in` loop to extract all the names and
+         * values from the `parameters` object.
+         *
+         * The two sources of parameters are: the query string in the URL of the
+         * main SWF file, and the value of the `FlashVars` HTML parameter
+         * (this affects only the main SWF file).
+         *
+         * The `parameters` property replaces the ActionScript 1.0 and
+         * 2.0 technique of providing SWF file parameters as properties of the main
+         * timeline.
+         *
+         * The value of the `parameters` property is null for Loader
+         * objects that contain SWF files that use ActionScript 1.0 or 2.0. It is
+         * only non-null for Loader objects that contain SWF files that use
+         * ActionScript 3.0.
+         */
+        get: function () {
+            if (!this._parameters) {
+                this._parameters = this.sec.createObjectFromJS(Object.assign({}, this._urlParameters, this._flashVars));
+            }
+            return this._parameters;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "parentAllowsChild", {
+        /**
+         * Expresses the trust relationship from Loader(parent) to the content
+         * (child). If the parent has allowed the child access, `true`;
+         * otherwise, `false`. This property is set to `true`
+         * if the parent object called the `allowDomain()` method to grant
+         * permission to the child domain or if a URL policy file is loaded at the
+         * parent domain granting permission to the child domain. If child and parent
+         * are in the same domain, this property is set to `true`.
+         *
+         * For more information related to security, see the Flash Player
+         * Developer Center Topic: [Security](http://www.adobe.com/go/devnet_security_en).
+         *
+         * @throws Error Thrown if the file is not downloaded sufficiently to
+         *               retrieve the requested information.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/LoaderInfo', 'get parentAllowsChild', '');
+            return false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "parentSandboxBridge", {
+        /**
+         * A object that can be set by code in the Loader object's sandbox to expose
+         * properties and methods that can be accessed by the loaded content's code.
+         * This _sandbox bridge_ lets content from a non-application domain have
+         * controlled access to scripts in the AIR application sandbox, and vice versa.
+         * The sandbox bridge serves as a gateway between the sandboxes, providing
+         * explicit interaction between application and non-application security
+         * sandboxes.
+         *
+         * @throws SecurityError Only content in the Loader object's sandbox can set
+         *         this property.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/LoaderInfo', 'get parentSandboxBridge', '');
+            return null;
+        },
+        set: function (door) {
+            // @todo
+            Debug.throwPIR('playerglobals/display/LoaderInfo', 'set parentSandboxBridge', '');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "sameDomain", {
+        /**
+         * Expresses the domain relationship between the loader and the content:
+         * `true` if they have the same origin domain; `false`
+         * otherwise.
+         *
+         * @throws Error Thrown if the file is not downloaded sufficiently to
+         *               retrieve the requested information.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/LoaderInfo', 'get sameDomain', '');
+            return false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "sharedEvents", {
+        /**
+         * An EventDispatcher instance that can be used to exchange events across
+         * security boundaries. Even when the Loader object and the loaded content
+         * originate from security domains that do not trust one another, both can
+         * access `sharedEvents` and send and receive events via this
+         * object.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/LoaderInfo', 'get sharedEvents', '');
+            return null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "swfVersion", {
+        /**
+         * The file format version of the loaded SWF file. The file format is
+         * specified using the enumerations in the SWFVersion class, such as
+         * `SWFVersion.FLASH7` and `SWFVersion.FLASH9`.
+         *
+         * @throws Error If the file is not downloaded sufficiently to retrieve
+         *               the requested information.
+         * @throws Error If the file is not a SWF file.
+         */
+        get: function () {
+            return this._swfVersion;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "uncaughtErrorEvents", {
+        /**
+         * An object that dispatches an `uncaughtError` event when an
+         * unhandled error occurs in code in this LoaderInfo object's SWF file. An
+         * uncaught error happens when an error is thrown outside of any
+         * `try..catch` blocks or when an ErrorEvent object is dispatched
+         * with no registered listeners.
+         *
+         * This property is created when the SWF associated with this LoaderInfo
+         * has finished loading. Until then the `uncaughtErrorEvents`
+         * property is `null`. In an ActionScript-only project, you can
+         * access this property during or after the execution of the constructor
+         * function of the main class of the SWF file. For a Flex project, the
+         * `uncaughtErrorEvents` property is available after the
+         * `applicationComplete` event is dispatched.
+         */
+        get: function () {
+            return this._loader.uncaughtErrorEvents;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "url", {
+        /**
+         * The URL of the media being loaded.
+         *
+         * Before the first `progress` event is dispatched by this
+         * LoaderInfo object's corresponding Loader object, the value of the
+         * `url` property might reflect only the initial URL specified in
+         * the call to the `load()` method of the Loader object. After the
+         * first `progress` event, the `url` property reflects
+         * the media's final URL, after any redirects and relative URLs are
+         * resolved.
+         *
+         * In some cases, the value of the `url` property is truncated;
+         * see the `isURLInaccessible` property for details.
+         */
+        get: function () {
+            if (this._url.includes('?')) {
+                this._url = this._url.substr(0, this._url.indexOf('?'));
+            }
+            return this._url;
+        },
+        set: function (value) {
+            this._setURL(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LoaderInfo.prototype, "width", {
+        /**
+         * The nominal width of the loaded content. This value might differ from the
+         * actual width at which the content is displayed, since the loaded content
+         * or its parent display objects might be scaled.
+         *
+         * @throws Error If the file is not downloaded sufficiently to retrieve the
+         *               requested information.
+         */
+        get: function () {
+            var node = AVMStage.instance().view.getNode(this._container);
+            var box = PickGroup.getInstance().getBoundsPicker(node).getBoxBounds(node);
+            return (box == null) ? 0 : box.width;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Returns the LoaderInfo object associated with a SWF file defined as an
+     * object.
+     *
+     * @param object The object for which you want to get an associated
+     *               LoaderInfo object.
+     * @return The associated LoaderInfo object. Returns null when called
+     *         in non-debugger builds (or when debugging is not enabled) or if
+     *         the referenced object does not have an associated LoaderInfo
+     *         object (such as some objects used by the AIR runtime).
+     * @throws SecurityError The caller is not running in the local trusted
+     *                       sandbox.
+     */
+    LoaderInfo.getLoaderInfoByDefinition = function (object) {
+        // @todo
+        Debug.throwPIR('playerglobals/display/LoaderInfo', 'static getLoaderInfoByDefinition', '');
+        return null;
+    };
+    LoaderInfo.prototype._setApplicationDomain = function (value) {
+        this._applicationDomain = value
+            || new this.sec.flash.system.ApplicationDomain(ApplicationDomain.currentDomain);
+    };
+    return LoaderInfo;
+}(EventDispatcher));
+export { LoaderInfo };