@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/net/FileFilter.d.ts

@@ -0,0 +1,13 @@
+import { ASObject } from '@awayfl/avm2';
+export declare class FileFilter extends ASObject {
+    private _description;
+    private _extension;
+    private _macType;
+    get description(): string;
+    set description(value: string);
+    get extension(): string;
+    set extension(value: string);
+    get macType(): string;
+    set macType(value: string);
+}
+//# sourceMappingURL=FileFilter.d.ts.map

package/dist/lib/net/FileFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileFilter.d.ts","sourceRoot":"","sources":["../../../lib/net/FileFilter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,qBAAa,UAAW,SAAQ,QAAQ;IAEvC,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAS;IAEzB,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED,IAAW,WAAW,CAAC,KAAK,EAAE,MAAM,EAEnC;IAED,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED,IAAW,SAAS,CAAC,KAAK,EAAE,MAAM,EAEjC;IAED,IAAW,OAAO,IAAI,MAAM,CAE3B;IAED,IAAW,OAAO,CAAC,KAAK,EAAE,MAAM,EAE/B;CACD"}

package/dist/lib/net/FileFilter.js

@@ -0,0 +1,40 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+var FileFilter = /** @class */ (function (_super) {
+    __extends(FileFilter, _super);
+    function FileFilter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(FileFilter.prototype, "description", {
+        get: function () {
+            return this._description;
+        },
+        set: function (value) {
+            this._description = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileFilter.prototype, "extension", {
+        get: function () {
+            return this._extension;
+        },
+        set: function (value) {
+            this._extension = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileFilter.prototype, "macType", {
+        get: function () {
+            return this._macType;
+        },
+        set: function (value) {
+            this._macType = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return FileFilter;
+}(ASObject));
+export { FileFilter };

package/dist/lib/net/FileReference.d.ts

@@ -0,0 +1,49 @@
+import { URLRequest } from './URLRequest';
+import { EventDispatcher } from '../events/EventDispatcher';
+import { ByteArray } from '../utils/ByteArray';
+import { FileFilter } from './FileFilter';
+import { ASObject } from '@awayfl/avm2';
+export declare class FileReference extends EventDispatcher {
+    static forceNativeMethods: boolean;
+    private _creationDate;
+    private _modificationDate;
+    private _name;
+    private _size;
+    private _creator;
+    private _type;
+    private _permissionStatus;
+    private _extension;
+    private _data;
+    constructor();
+    get size(): number;
+    set size(value: number);
+    get data(): ByteArray;
+    set data(value: ByteArray);
+    get extension(): string;
+    set extension(value: string);
+    get permissionStatus(): string;
+    set permissionStatus(value: string);
+    get type(): string;
+    set type(value: string);
+    get creator(): string;
+    set creator(value: string);
+    get name(): string;
+    set name(value: string);
+    get modificationDate(): Date;
+    set modificationDate(value: Date);
+    get creationDate(): Date;
+    set creationDate(value: Date);
+    private static knownMimeTypes;
+    browse(typelist: FileFilter[]): boolean;
+    upload(url: URLRequest): boolean;
+    load(): void;
+    save(data: string | ASObject, _defaultFileName?: string): void;
+    private _useFileSystemSave;
+    private _sendCancelEvent;
+    private _sendCompleteEvent;
+    private _sendSelectEvent;
+    requestPermission(): void;
+    download(url: URLRequest, defaultFileName: string): boolean;
+    cancel(): void;
+}
+//# sourceMappingURL=FileReference.d.ts.map

package/dist/lib/net/FileReference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileReference.d.ts","sourceRoot":"","sources":["../../../lib/net/FileReference.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAWxC,qBAAa,aAAc,SAAQ,eAAe;IACjD,OAAc,kBAAkB,UAAQ;IAExC,OAAO,CAAC,aAAa,CAAO;IAC5B,OAAO,CAAC,iBAAiB,CAAO;IAChC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,KAAK,CAAY;;IAMzB,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,IAAI,CAAC,KAAK,EAAE,MAAM,EAE5B;IAED,IAAW,IAAI,IAAI,SAAS,CAE3B;IAED,IAAW,IAAI,CAAC,KAAK,EAAE,SAAS,EAE/B;IAED,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED,IAAW,SAAS,CAAC,KAAK,EAAE,MAAM,EAEjC;IAED,IAAW,gBAAgB,IAAI,MAAM,CAEpC;IAED,IAAW,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAExC;IAED,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,IAAI,CAAC,KAAK,EAAE,MAAM,EAE5B;IAED,IAAW,OAAO,IAAI,MAAM,CAE3B;IAED,IAAW,OAAO,CAAC,KAAK,EAAE,MAAM,EAE/B;IAED,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,IAAI,CAAC,KAAK,EAAE,MAAM,EAE5B;IAED,IAAW,gBAAgB,IAAI,IAAI,CAElC;IAED,IAAW,gBAAgB,CAAC,KAAK,EAAE,IAAI,EAEtC;IAED,IAAW,YAAY,IAAI,IAAI,CAE9B;IAED,IAAW,YAAY,CAAC,KAAK,EAAE,IAAI,EAElC;IAED,OAAO,CAAC,MAAM,CAAC,cAAc,CAI5B;IAGM,MAAM,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,OAAO;IA0DvC,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO;IAMhC,IAAI;IAKJ,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,gBAAgB,GAAE,MAAa;IAMpE,OAAO,CAAC,kBAAkB;IAiE1B,OAAO,CAAC,gBAAgB;IASxB,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,gBAAgB;IAUjB,iBAAiB;IAKjB,QAAQ,CAAC,GAAG,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,GAAG,OAAO;IAM3D,MAAM;CAGb"}

package/dist/lib/net/FileReference.js

@@ -0,0 +1,271 @@
+import { __extends } from "tslib";
+import { EventDispatcher } from '../events/EventDispatcher';
+import { ByteArray } from '../utils/ByteArray';
+import { Event } from '../events/Event';
+import { Settings } from '../Settings';
+var USE_FILE_PICKER = ('showSaveFilePicker' in self) && Settings.ENABLE_FILE_PICKER;
+if (USE_FILE_PICKER) {
+    console.debug('[FileReference] `showSaveFilePicker` used for save()');
+}
+var FileReference = /** @class */ (function (_super) {
+    __extends(FileReference, _super);
+    function FileReference() {
+        return _super.call(this) || this;
+    }
+    Object.defineProperty(FileReference.prototype, "size", {
+        get: function () {
+            return this._size;
+        },
+        set: function (value) {
+            this._size = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileReference.prototype, "data", {
+        get: function () {
+            return this._data;
+        },
+        set: function (value) {
+            this._data = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileReference.prototype, "extension", {
+        get: function () {
+            return this._extension;
+        },
+        set: function (value) {
+            this._extension = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileReference.prototype, "permissionStatus", {
+        get: function () {
+            return this._permissionStatus;
+        },
+        set: function (value) {
+            this._permissionStatus = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileReference.prototype, "type", {
+        get: function () {
+            return this._type;
+        },
+        set: function (value) {
+            this._type = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileReference.prototype, "creator", {
+        get: function () {
+            return this._creator;
+        },
+        set: function (value) {
+            this._creator = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileReference.prototype, "name", {
+        get: function () {
+            return this._name;
+        },
+        set: function (value) {
+            this._name = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileReference.prototype, "modificationDate", {
+        get: function () {
+            return this._modificationDate;
+        },
+        set: function (value) {
+            this._modificationDate = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileReference.prototype, "creationDate", {
+        get: function () {
+            return this._creationDate;
+        },
+        set: function (value) {
+            this._creationDate = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //Displays a file-browsing dialog box that lets the user select a file to upload.
+    FileReference.prototype.browse = function (typelist) {
+        var _a;
+        var _this = this;
+        var knownTypes = FileReference.knownMimeTypes;
+        var openDialog = window.showOpenFilePicker;
+        if (!openDialog) {
+            console.warn('[flash/net/FileReference] FileSystem API not supported!');
+            return false;
+        }
+        var types = [];
+        for (var i = 0; i < typelist.length; i++) {
+            var filter = typelist[i];
+            var extension = filter.extension.slice(filter.extension.lastIndexOf('.'));
+            var mime = extension in knownTypes ? knownTypes[extension]['mime'] : 'application/unknown';
+            types.push({
+                description: filter.description,
+                accept: (_a = {}, _a[mime] = extension, _a)
+            });
+        }
+        var options = {
+            types: types
+        };
+        openDialog(options)
+            .then(function (fileHandler) {
+            _this._sendSelectEvent();
+            return fileHandler[0].getFile();
+        })
+            .then(function (file) {
+            _this.modificationDate = new Date(file.lastModified);
+            _this.name = file.name;
+            _this.size = file.size;
+            _this.type = file.type;
+            var extIndex = file.name.lastIndexOf('.');
+            _this.extension = extIndex >= 0 ? file.name.slice(extIndex + 1) : null;
+            return file.arrayBuffer();
+        })
+            .then(function (buf) {
+            _this.data = new ByteArray(buf.byteLength);
+            _this.data.setArrayBuffer(buf);
+            _this._sendCompleteEvent();
+        })
+            .catch(function (e) {
+            if (e.code === 20 && e.message === 'The user aborted a request.') {
+                _this._sendCancelEvent();
+                return;
+            }
+            console.warn('[flash/net/FileReference] FileSystem API Reject `showOpenFilePicker` request:', e);
+        });
+        return true;
+    };
+    //Starts the upload of the file to a remote server.
+    FileReference.prototype.upload = function (url) {
+        console.log('upload not implemented yet in flash/FileReference');
+        return true;
+    };
+    //Starts the load of a local file selected by a user.
+    FileReference.prototype.load = function () {
+        console.log('load not implemented yet in flash/FileReference');
+    };
+    //Opens a dialog box that lets the user save a file to the local filesystem.
+    FileReference.prototype.save = function (data, _defaultFileName) {
+        if (_defaultFileName === void 0) { _defaultFileName = null; }
+        if (this._useFileSystemSave(data, _defaultFileName)) {
+            return;
+        }
+    };
+    FileReference.prototype._useFileSystemSave = function (data, name) {
+        var _a;
+        var _this = this;
+        if (name === void 0) { name = ''; }
+        var knownTypes = FileReference.knownMimeTypes;
+        var isString = typeof data === 'string';
+        var isByteArray = data.getBytes !== undefined;
+        var ext = name.slice(name.lastIndexOf('.'));
+        if (!USE_FILE_PICKER)
+            return false;
+        // this is draft API
+        // https://web.dev/file-system-access/
+        var openDialog = window.showSaveFilePicker;
+        if (!openDialog) {
+            console.warn('[flash/net/FileReference] FileSystem API not supported!');
+            return false;
+        }
+        if (!isString && !isByteArray) {
+            console.warn('[FileReference] Save is only supported for String and ByteArray');
+            return;
+        }
+        var types = [];
+        if (ext in knownTypes) {
+            var mime = knownTypes[ext].mime;
+            types[0] = {
+                description: knownTypes[ext].description,
+                accept: (_a = {}, _a[mime] = ext, _a),
+            };
+        }
+        else {
+            types[0] = {
+                description: '',
+                accept: { 'application/unknown': ext },
+            };
+        }
+        var options = {
+            suggestedName: name || '',
+            types: types
+        };
+        openDialog(options)
+            .then(function (fileHandler) {
+            _this._sendSelectEvent();
+            return fileHandler.createWritable();
+        })
+            .then(function (stream) {
+            return stream
+                .write(isByteArray ? data.getBytes() : data)
+                .then(function () { return stream.close(); });
+        })
+            .then(function (_e) {
+            _this._sendCompleteEvent();
+        })
+            .catch(function (e) {
+            if (e.code === 20 && e.message === 'The user aborted a request.') {
+                _this._sendCancelEvent();
+                return;
+            }
+            console.warn('[flash/net/FileReference] FileSystem API Reject `showSaveFilePicker` request:', e);
+        });
+    };
+    FileReference.prototype._sendCancelEvent = function () {
+        var event = new this.sec.flash.events.Event(Event.CANCEL);
+        event.currentTarget = this;
+        event.target = this;
+        this.dispatchEvent(event);
+    };
+    FileReference.prototype._sendCompleteEvent = function () {
+        var event = new this.sec.flash.events.Event(Event.COMPLETE);
+        event.currentTarget = this;
+        event.target = this;
+        this.dispatchEvent(event);
+    };
+    FileReference.prototype._sendSelectEvent = function () {
+        var event = new this.sec.flash.events.Event(Event.SELECT);
+        event.currentTarget = this;
+        event.target = this;
+        this.dispatchEvent(event);
+    };
+    //Requests permission to access filesystem.
+    FileReference.prototype.requestPermission = function () {
+        console.log('upload not implemented yet in flash/FileReference');
+    };
+    //Opens a dialog box that lets the user download a file from a remote server.
+    FileReference.prototype.download = function (url, defaultFileName) {
+        console.log('download not implemented yet in flash/FileReference');
+        return true;
+    };
+    //Cancels any ongoing upload or download operation on this FileReference object.
+    FileReference.prototype.cancel = function () {
+        console.log('cancel not implemented yet in flash/FileReference');
+    };
+    FileReference.forceNativeMethods = true;
+    FileReference.knownMimeTypes = {
+        '.jpeg': { 'mime': 'image/jpeg', 'description': 'JPEG images' },
+        '.jpg': { 'mime': 'image/jpeg', 'description': 'JPEG images' },
+        '.txt': { 'mime': 'text/plain', 'description': 'Text documents' },
+    };
+    return FileReference;
+}(EventDispatcher));
+export { FileReference };

package/dist/lib/net/LocalConnection.d.ts

@@ -0,0 +1,26 @@
+import { EventDispatcher } from '../events/EventDispatcher';
+import { ASObject } from '@awayfl/avm2';
+export declare class LocalConnection extends EventDispatcher {
+    static classInitializer: any;
+    constructor();
+    static get isSupported(): boolean;
+    private _domain;
+    private _secure;
+    private _client;
+    private _connectionName;
+    private _allowedInsecureDomains;
+    private _allowedSecureDomains;
+    close(): void;
+    connect(connectionName: string): void;
+    send(connectionName: string, methodName: string, ...args: any[]): void;
+    get client(): ASObject;
+    set client(client: ASObject);
+    allowDomain(...domains: string[]): void;
+    allowInsecureDomain(...domains: string[]): void;
+    private _allowDomains;
+    handleMessage(methodName: string, argsBuffer: ArrayBuffer): void;
+    get domain(): string;
+    get isPerUser(): boolean;
+    set isPerUser(newValue: boolean);
+}
+//# sourceMappingURL=LocalConnection.d.ts.map

package/dist/lib/net/LocalConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalConnection.d.ts","sourceRoot":"","sources":["../../../lib/net/LocalConnection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAE5D,OAAO,EAIN,QAAQ,EAKR,MAAM,cAAc,CAAC;AA0BtB,qBAAa,eAAgB,SAAQ,eAAe;IAEnD,MAAM,CAAC,gBAAgB,MAAQ;;IAe/B,MAAM,KAAK,WAAW,YAErB;IAED,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAU;IAEzB,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,eAAe,CAAS;IAGhC,OAAO,CAAC,uBAAuB,CAAW;IAC1C,OAAO,CAAC,qBAAqB,CAAW;IAExC,KAAK,IAAI,IAAI;IAgBb,OAAO,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAoCrC,IAAI,CAAC,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,IAAI,OAAA,GAAG,IAAI;IAqC/D,IAAI,MAAM,IAAI,QAAQ,CAErB;IAED,IAAI,MAAM,CAAC,MAAM,EAAE,QAAQ,EAK1B;IAED,WAAW,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAIvC,mBAAmB,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAM/C,OAAO,CAAC,aAAa;IAwBd,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,WAAW,GAAG,IAAI;IAiDvE,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,SAAS,IAAI,OAAO,CAGvB;IAED,IAAI,SAAS,CAAC,QAAQ,EAAE,OAAO,EAK9B;CACD"}

package/dist/lib/net/LocalConnection.js

@@ -0,0 +1,251 @@
+import { __extends } from "tslib";
+import { EventDispatcher } from '../events/EventDispatcher';
+//import { LocalConnectionService, LocalConnectionConnectResult } from "../../base/utilities/LocalConnectionService";
+import { axCoerceString, axIsCallable, axIsTypeString, Errors, ByteArray } from '@awayfl/avm2';
+import { assert, notImplemented, release, warning } from '@awayfl/swf-loader';
+import { ErrorEvent } from '../events/ErrorEvent';
+/**
+ * Copyright 2015 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.
+ */
+var LocalConnectionService = {};
+var LocalConnectionConnectResult = {};
+var forbiddenNames = ['send', 'connect', 'close', 'allowDomain', 'allowInsecureDomain', 'client', 'domain'];
+Object.freeze(forbiddenNames);
+var LocalConnection = /** @class */ (function (_super) {
+    __extends(LocalConnection, _super);
+    function LocalConnection() {
+        var _this = _super.call(this) || this;
+        _this._client = _this;
+        _this._connectionName = null;
+        _this._allowedInsecureDomains = [];
+        _this._allowedSecureDomains = [];
+        // tsc contains a definition for URL that's non-constructible.
+        var url = new URL(document.baseURI /*getCurrentABC().env.url*/);
+        _this._domain = url.hostname;
+        _this._secure = url.protocol === 'https:';
+        return _this;
+    }
+    Object.defineProperty(LocalConnection, "isSupported", {
+        get: function () {
+            return true;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LocalConnection.prototype.close = function () {
+        var connectionName = this._connectionName;
+        if (!connectionName) {
+            this.sec.throwError('ArgumentError', Errors.CloseNotConnectedError);
+        }
+        release || assert(typeof connectionName === 'string' && connectionName.length > 0);
+        this._connectionName = null;
+        // TODO: verify that these really are reset. For now, we aim to err on the safe side.
+        this._allowedInsecureDomains = [];
+        this._allowedSecureDomains = [];
+        //LocalConnectionService.closeConnection(connectionName, this);
+        notImplemented('public flash.net.LocalConnection::close');
+    };
+    LocalConnection.prototype.connect = function (connectionName) {
+        notImplemented('public flash.net.LocalConnection::connect');
+        return;
+        connectionName = axCoerceString(connectionName);
+        if (connectionName === null) {
+            this.sec.throwError('TypeError', Errors.NullPointerError, 'connectionName');
+        }
+        if (connectionName === '') {
+            this.sec.throwError('TypeError', Errors.EmptyStringError, 'connectionName');
+        }
+        // The only disallowed character for the connection name is ":".
+        if (connectionName.indexOf(':') > -1) {
+            this.sec.throwError('ArgumentError', Errors.InvalidParamError);
+        }
+        if (this._connectionName) {
+            this.sec.throwError('ArgumentError', Errors.AlreadyConnectedError);
+        }
+        var result = LocalConnectionService.createConnection(connectionName, this);
+        if (result === LocalConnectionConnectResult.AlreadyTaken) {
+            this.sec.throwError('ArgumentError', Errors.AlreadyConnectedError);
+        }
+        this._connectionName = connectionName;
+        release || assert(result === LocalConnectionConnectResult.Success);
+        if (this._allowedInsecureDomains.length) {
+            LocalConnectionService.allowDomains(connectionName, this, this._allowedInsecureDomains, false);
+        }
+        if (this._allowedSecureDomains.length) {
+            LocalConnectionService.allowDomains(connectionName, this, this._allowedSecureDomains, true);
+        }
+    };
+    LocalConnection.prototype.send = function (connectionName, methodName) {
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        notImplemented('public flash.net.LocalConnection::send');
+        return;
+        connectionName = axCoerceString(connectionName);
+        methodName = axCoerceString(methodName);
+        if (connectionName === null) {
+            this.sec.throwError('TypeError', Errors.NullPointerError, 'connectionName');
+        }
+        if (connectionName === '') {
+            this.sec.throwError('TypeError', Errors.EmptyStringError, 'connectionName');
+        }
+        if (methodName === null) {
+            this.sec.throwError('TypeError', Errors.NullPointerError, 'methodName');
+        }
+        if (methodName === '') {
+            this.sec.throwError('TypeError', Errors.EmptyStringError, 'methodName');
+        }
+        if (forbiddenNames.indexOf(methodName) > -1) {
+            this.sec.throwError('ArgumentError', Errors.InvalidParamError);
+        }
+        var serializedArgs = new ByteArray();
+        serializedArgs.writeObject(this.sec.createArrayUnsafe(args));
+        if (serializedArgs.length > 40 * 1024) {
+            this.sec.throwError('ArgumentError', Errors.ArgumentSizeError);
+        }
+        var argsBuffer = serializedArgs.getBytes().buffer;
+        try {
+            LocalConnectionService.send(connectionName, methodName, argsBuffer, this, this._domain, this._secure);
+        }
+        catch (e) {
+            // Not sure what to do here, this shouldn't happen. We'll just ignore it with a warning.
+            warning('Unknown error occurred in LocalConnection#send', e);
+        }
+    };
+    Object.defineProperty(LocalConnection.prototype, "client", {
+        get: function () {
+            return this._client;
+        },
+        set: function (client) {
+            if (!this.sec.AXObject.axIsType(client)) {
+                this.sec.throwError('ArgumentError', Errors.InvalidParamError);
+            }
+            this._client = client;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LocalConnection.prototype.allowDomain = function () {
+        var domains = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            domains[_i] = arguments[_i];
+        }
+        this._allowDomains(domains, true);
+    };
+    LocalConnection.prototype.allowInsecureDomain = function () {
+        var domains = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            domains[_i] = arguments[_i];
+        }
+        // allowInsecureDomain also allows secure domains.
+        this._allowDomains(domains, true);
+        this._allowDomains(domains, false);
+    };
+    LocalConnection.prototype._allowDomains = function (domains, secure) {
+        notImplemented('private flash.net.LocalConnection::_allowDomains');
+        return;
+        var result = [];
+        // If no connection has been made yet, store the domains for later retrieval.
+        if (!this._connectionName) {
+            result = secure ? this._allowedSecureDomains : this._allowedInsecureDomains;
+        }
+        for (var i = 0; i < domains.length; i++) {
+            var domain = domains[i];
+            if (!axIsTypeString(domain)) {
+                this.sec.throwError('ArgumentError', Errors.AllowDomainArgumentError);
+            }
+            if (result.indexOf(domain) === -1) {
+                result.push(domain);
+            }
+        }
+        if (this._connectionName) {
+            LocalConnectionService.allowDomains(this._connectionName, this, domains, secure);
+        }
+    };
+    LocalConnection.prototype.handleMessage = function (methodName, argsBuffer) {
+        var client = this._client;
+        var error;
+        if (!client.axHasPublicProperty(methodName) || forbiddenNames.indexOf(methodName) > -1) {
+            // Forbidden names really shouldn't reach this point, but should everything else fail,
+            // we just pretend not to have found them here.
+            error = this.sec.createError('ReferenceError', Errors.ReadSealedError, methodName, client.axClass.name.name);
+        }
+        else {
+            var handler = client.axGetPublicProperty(methodName);
+            if (!axIsCallable(handler)) {
+                // Non-callable handlers are just ignored.
+                return;
+            }
+            var ba = new ByteArray(argsBuffer);
+            var args = ba.readObject();
+            if (!this.sec.AXArray.axIsType(args)) {
+                error =
+                    this.sec.createError('TypeError', Errors.CheckTypeFailedError, args, 'Array');
+            }
+            else {
+                try {
+                    handler.apply(client, args.value);
+                }
+                catch (e) {
+                    error = e;
+                }
+            }
+        }
+        if (!error) {
+            return;
+        }
+        var errorEvent = new ErrorEvent('asyncError', false, false, 'Error #2095: flash.net.LocalConnection was' +
+            ' unable to invoke' +
+            ' callback ' + methodName + '.', error.errorID);
+        if (this.hasEventListener('asyncError')) {
+            try {
+                this.dispatchEvent(errorEvent);
+            }
+            catch (e) {
+                console.warn('Exception encountered during asyncErrorEvent handling in ' +
+                    'LocalConnection sender.');
+            }
+        }
+        else {
+            // TODO: add the error to the LoaderInfo#uncaughtErrorEvents list.
+            console.warn('No handler for asyncError on LocalConnection sender, not sending event', errorEvent);
+        }
+    };
+    Object.defineProperty(LocalConnection.prototype, "domain", {
+        get: function () {
+            return this._domain;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LocalConnection.prototype, "isPerUser", {
+        get: function () {
+            // We always return true, because everything else would be a lie.
+            return true;
+        },
+        set: function (newValue) {
+            !!newValue;
+            // Ignored. See
+            // https://blogs.adobe.com/simplicity/2009/08/localconnectionisperuser_in_ai.html for an
+            // explanation.
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LocalConnection.classInitializer = null;
+    return LocalConnection;
+}(EventDispatcher));
+export { LocalConnection };