@afterswf/playerglobal 0.0.0-stage → 0.2.460

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

@@ -0,0 +1,80 @@
+import { EventDispatcher } from '../events/EventDispatcher';
+import { ASArray, ASObject } from '@awayfl/avm2';
+import { Responder } from './Responder';
+/**
+ * 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.
+ */
+export declare class NetConnection extends EventDispatcher {
+    static classInitializer: any;
+    constructor();
+    close(): void;
+    addHeader(operation: string, mustUnderstand?: Boolean, param?: any): void;
+    call(command: string, responder: Responder): void;
+    private static _netStatusEventClass;
+    private _httpCallId;
+    private _pendingResponders;
+    private _debugAMF;
+    private _makeStatusInfo;
+    private _dispatchStatus;
+    private static _byteArrayClass;
+    private _newAMFByteArray;
+    private _httpCall;
+    private _handleRemotingResponse;
+    private _httpFail;
+    private static _buildRemotingPacket;
+    private static _parseRemotingPacket;
+    static _defaultObjectEncoding: number;
+    static get defaultObjectEncoding(): number;
+    static set defaultObjectEncoding(version: number);
+    private _connected;
+    private _uri;
+    private _client;
+    private _objectEncoding;
+    private _proxyType;
+    private _connectedProxyType;
+    private _usingTLS;
+    private _protocol;
+    private _maxPeerConnections;
+    private _nearID;
+    private _farID;
+    private _nearNonce;
+    private _farNonce;
+    private _unconnectedPeerStreams;
+    private _rtmpConnection;
+    private _rtmpCreateStreamCallbacks;
+    get connected(): boolean;
+    get uri(): string;
+    connect(command: string): void;
+    _createRtmpStream(callback: any): void;
+    get client(): ASObject;
+    set client(object: ASObject);
+    get objectEncoding(): number;
+    set objectEncoding(version: number);
+    get proxyType(): string;
+    set proxyType(ptype: string);
+    get connectedProxyType(): string;
+    get usingTLS(): boolean;
+    get protocol(): string;
+    get maxPeerConnections(): number;
+    set maxPeerConnections(maxPeers: number);
+    get nearID(): string;
+    get farID(): string;
+    get nearNonce(): string;
+    get farNonce(): string;
+    get unconnectedPeerStreams(): ASArray;
+    invoke(index: number): any;
+    private _invoke;
+}
+//# sourceMappingURL=NetConnection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NetConnection.d.ts","sourceRoot":"","sources":["../../../lib/net/NetConnection.ts"],"names":[],"mappings":"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"}

package/dist/lib/net/NetConnection.js

@@ -0,0 +1,447 @@
+import { __extends, __spreadArray } from "tslib";
+import { EventDispatcher } from '../events/EventDispatcher';
+import { axCoerceString, Multiname } from '@awayfl/avm2';
+import { NetStatusEvent } from '../events/NetStatusEvent';
+import { somewhatImplemented, release, notImplemented } from '@awayfl/swf-loader';
+/**
+ * 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.
+ */
+// Class: NetConnection
+var NetConnection = /** @class */ (function (_super) {
+    __extends(NetConnection, _super);
+    function NetConnection() {
+        var _this = _super.call(this) || this;
+        _this._httpCallId = 0;
+        _this._connected = false;
+        _this._proxyType = 'none';
+        _this._objectEncoding = NetConnection.defaultObjectEncoding;
+        _this._usingTLS = false;
+        return _this;
+        //Telemetry.instance.reportTelemetry({topic: 'feature', feature: Telemetry.Feature.NETCONNECTION_FEATURE});
+    }
+    // JS -> AS Bindings
+    NetConnection.prototype.close = function () {
+        this.invoke(1);
+    };
+    NetConnection.prototype.addHeader = function (operation, mustUnderstand, param) {
+        if (mustUnderstand === void 0) { mustUnderstand = false; }
+        if (param === void 0) { param = null; }
+        this._invoke(3, [axCoerceString(operation), !!mustUnderstand, param]);
+    };
+    NetConnection.prototype.call = function (command, responder /* more args can be provided */) {
+        command = axCoerceString(command);
+        // Native methods receive AS3 arguments flat (no ...rest collection) — everything
+        // after `responder` is a call argument to be serialised.
+        var callArgs = Array.prototype.slice.call(arguments, 2);
+        this._httpCall(command, responder, callArgs);
+    };
+    NetConnection.prototype._debugAMF = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (typeof self !== 'undefined' && self.__AWAYFL_AMF_DEBUG)
+            console.log.apply(console, __spreadArray(['[AMF]'], args, true));
+    };
+    NetConnection.prototype._makeStatusInfo = function (code, level, description) {
+        var info = { code: code, level: level };
+        if (description !== undefined)
+            info.description = description;
+        return this.sec.createObjectFromJS(info);
+    };
+    NetConnection.prototype._dispatchStatus = function (code, level, description) {
+        this._debugAMF('netStatus ->', code, description || '');
+        try {
+            // Events handed to compiled AS3 must be real AVM2 instances (axConstruct on the
+            // AXClass); a raw `new NetStatusEvent(...)` lacks runtime traits and property
+            // access from compiled code fails on it.
+            if (!NetConnection._netStatusEventClass) {
+                NetConnection._netStatusEventClass = this.sec.application.getClass(Multiname.FromFQNString('flash.events.NetStatusEvent', 0 /* NamespaceType.Public */));
+            }
+            var event_1 = NetConnection._netStatusEventClass.axConstruct([NetStatusEvent.NET_STATUS, false, false, this._makeStatusInfo(code, level, description)]);
+            event_1.currentTarget = this;
+            event_1.target = this;
+            this.dispatchEvent(event_1);
+        }
+        catch (e) {
+            console.warn('[NetConnection] netStatus dispatch failed:', e);
+        }
+    };
+    NetConnection.prototype._newAMFByteArray = function () {
+        // ByteArray's buffer machinery lives on DataBuffer.prototype and is merged onto the
+        // VM-linked prototype via instanceNatives — a raw `new ByteArray()` lacks it, so the
+        // instance must be constructed through the AXClass.
+        if (!NetConnection._byteArrayClass) {
+            NetConnection._byteArrayClass = this.sec.application.getClass(Multiname.FromFQNString('flash.utils.ByteArray', 0 /* NamespaceType.Public */));
+        }
+        var ba = NetConnection._byteArrayClass.axConstruct([]);
+        // the AMF codec resolves classes/objects through the security domain
+        ba.sec = this.sec;
+        return ba;
+    };
+    NetConnection.prototype._httpCall = function (command, responder, callArgs) {
+        var _this = this;
+        var id = String(++this._httpCallId);
+        this._debugAMF('call ->', command, 'id', id);
+        try {
+            if (!this._pendingResponders)
+                this._pendingResponders = {};
+            if (responder)
+                this._pendingResponders[id] = responder;
+            var ba = this._newAMFByteArray();
+            ba._objectEncoding = 3; // AMF3
+            ba.writeByte(0x11); // AMF0 avmplus marker: body is AMF3
+            ba.writeObject(this.sec.createArray(callArgs));
+            var body = new Uint8Array(ba._buffer.slice(0, ba._length));
+            var packet = NetConnection._buildRemotingPacket(command, id, body);
+            if (!this._uri) {
+                this._httpFail(id, 'NetConnection is not connected (uri is null)');
+                return;
+            }
+            fetch(this._uri, {
+                method: 'POST',
+                credentials: 'include',
+                headers: { 'Content-Type': 'application/x-amf' },
+                body: packet
+            }).then(function (r) {
+                if (!r.ok)
+                    throw new Error('HTTP ' + r.status);
+                var ct = (r.headers.get('content-type') || '').toLowerCase();
+                // A misconfigured gateway can answer 200 with an HTML error page; surface it
+                // as a fault instead of feeding non-AMF bytes to the parser.
+                if (ct.indexOf('application/x-amf') === -1) {
+                    return r.text().then(function (t) {
+                        throw new Error('Non-AMF response (content-type: ' + (ct || 'none') + '): '
+                            + t.replace(/\s+/g, ' ').slice(0, 300));
+                    });
+                }
+                return r.arrayBuffer();
+            }).then(function (buf) {
+                _this._handleRemotingResponse(buf);
+            }).catch(function (err) {
+                _this._httpFail(id, String((err && err.message) || err));
+            });
+        }
+        catch (e) {
+            this._debugAMF('call FAILED synchronously:', e);
+            this._httpFail(id, String((e && e.message) || e));
+        }
+    };
+    NetConnection.prototype._handleRemotingResponse = function (buf) {
+        var messages;
+        try {
+            messages = NetConnection._parseRemotingPacket(buf);
+        }
+        catch (e) {
+            console.warn('[NetConnection] AMF response parse failed:', e);
+            return;
+        }
+        for (var i = 0; i < messages.length; i++) {
+            var msg = messages[i];
+            var value = void 0;
+            try {
+                var ba = this._newAMFByteArray();
+                ba.setArrayBuffer(msg.body);
+                ba._position = 0;
+                ba._objectEncoding = 0; // AMF0 reader; handles the 0x11 -> AMF3 marker
+                value = ba.readObject();
+            }
+            catch (e) {
+                console.warn('[NetConnection] AMF body decode failed for', msg.target, e);
+                continue;
+            }
+            var match = /^\/([^\/]*)\/(onResult|onStatus)$/.exec(msg.target);
+            if (!match) {
+                console.warn('[NetConnection] unrecognised AMF response target:', msg.target);
+                continue;
+            }
+            var id = match[1], kind = match[2];
+            var responder = this._pendingResponders && this._pendingResponders[id];
+            if (this._pendingResponders)
+                delete this._pendingResponders[id];
+            this._debugAMF('response', kind, 'id', id, '->', responder ? 'responder' : '(no responder)');
+            if (responder) {
+                try {
+                    kind === 'onResult' ? responder.invokeResult(value) : responder.invokeStatus(value);
+                }
+                catch (e) {
+                    console.warn('[NetConnection] responder callback threw:', e);
+                }
+            }
+            else if (kind === 'onStatus') {
+                this._dispatchStatus('NetConnection.Call.Failed', 'error');
+            }
+        }
+    };
+    NetConnection.prototype._httpFail = function (id, description) {
+        this._debugAMF('call failed id', id, ':', description);
+        var responder = this._pendingResponders && this._pendingResponders[id];
+        if (this._pendingResponders)
+            delete this._pendingResponders[id];
+        if (responder) {
+            try {
+                responder.invokeStatus(this._makeStatusInfo('NetConnection.Call.Failed', 'error', description));
+                return;
+            }
+            catch (e) {
+                console.warn('[NetConnection] responder status callback threw:', e);
+            }
+        }
+        this._dispatchStatus('NetConnection.Call.Failed', 'error', description);
+    };
+    /* AMF remoting packet: u16 version | u16 headerCount | u16 messageCount, then per
+     * message: utf targetURI | utf responseURI | u32 bodyLength | AMF body. */
+    NetConnection._buildRemotingPacket = function (target, responseId, body) {
+        var enc = new TextEncoder();
+        var head = [];
+        var u16 = function (v) { return head.push((v >>> 8) & 0xff, v & 0xff); };
+        var u32 = function (v) { return head.push((v >>> 24) & 0xff, (v >>> 16) & 0xff, (v >>> 8) & 0xff, v & 0xff); };
+        var utf = function (str) {
+            var b = enc.encode(str);
+            u16(b.length);
+            for (var i = 0; i < b.length; i++)
+                head.push(b[i]);
+        };
+        u16(3); // version 3 (AMF3-capable)
+        u16(0); // headers
+        u16(1); // messages
+        utf(target);
+        utf('/' + responseId);
+        u32(body.length);
+        var out = new Uint8Array(head.length + body.length);
+        out.set(head, 0);
+        out.set(body, head.length);
+        return out;
+    };
+    NetConnection._parseRemotingPacket = function (buf) {
+        var dv = new DataView(buf);
+        var dec = new TextDecoder();
+        var pos = 0;
+        var u16 = function () { var v = dv.getUint16(pos); pos += 2; return v; };
+        var u32 = function () { var v = dv.getUint32(pos); pos += 4; return v; };
+        var utf = function () { var n = u16(); var s = dec.decode(new Uint8Array(buf, pos, n)); pos += n; return s; };
+        var messages = [];
+        u16(); // version
+        var headers = u16();
+        for (var h = 0; h < headers; h++) {
+            utf();
+            pos += 1; // name, mustUnderstand
+            var len = u32();
+            if (len !== 0xffffffff)
+                pos += len;
+        }
+        var count = u16();
+        for (var m = 0; m < count; m++) {
+            var target = utf();
+            utf(); // response uri (unused in replies)
+            var len = u32();
+            var body = void 0;
+            if (len !== 0xffffffff && pos + len <= buf.byteLength) {
+                body = buf.slice(pos, pos + len);
+                pos += len;
+            }
+            else {
+                body = buf.slice(pos);
+                pos = buf.byteLength;
+            }
+            messages.push({ target: target, body: body });
+        }
+        return messages;
+    };
+    Object.defineProperty(NetConnection, "defaultObjectEncoding", {
+        get: function () {
+            return NetConnection._defaultObjectEncoding;
+        },
+        set: function (version /*uint*/) {
+            version = version >>> 0;
+            NetConnection._defaultObjectEncoding = version;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetConnection.prototype, "connected", {
+        get: function () {
+            return this._connected;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetConnection.prototype, "uri", {
+        get: function () {
+            return this._uri;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    NetConnection.prototype.connect = function (command) {
+        var _this = this;
+        command = axCoerceString(command);
+        this._uri = command;
+        // A null command or an HTTP(S) url is a Flash Remoting gateway connection: it always
+        // "succeeds" immediately — calls are independent HTTP POSTs. Dispatch async so
+        // listeners registered right after connect() still receive the event.
+        if (!command || !/^rtmpt?s?:/i.test(command)) {
+            this._connected = true;
+            Promise.resolve().then(function () { return _this._dispatchStatus('NetConnection.Connect.Success', 'status'); });
+            return;
+        }
+        // RTMP / RTMPT / RTMPS streaming transports are not implemented.
+        console.warn('[NetConnection] rtmp transports are not implemented:', command);
+        this._dispatchStatus('NetConnection.Connect.Failed', 'error');
+    };
+    NetConnection.prototype._createRtmpStream = function (callback) {
+        var transactionId = this._rtmpCreateStreamCallbacks.length;
+        this._rtmpCreateStreamCallbacks[transactionId] = callback;
+        this._rtmpConnection.createStream(transactionId, null);
+    };
+    Object.defineProperty(NetConnection.prototype, "client", {
+        get: function () {
+            return this._client;
+        },
+        set: function (object) {
+            this._client = object;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetConnection.prototype, "objectEncoding", {
+        get: function () {
+            return this._objectEncoding;
+        },
+        set: function (version /*uint*/) {
+            version = version >>> 0;
+            release || somewhatImplemented('public flash.net.NetConnection::set objectEncoding');
+            this._objectEncoding = version;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetConnection.prototype, "proxyType", {
+        get: function () {
+            return this._proxyType;
+        },
+        set: function (ptype) {
+            ptype = axCoerceString(ptype);
+            release || somewhatImplemented('public flash.net.NetConnection::set proxyType');
+            this._proxyType = ptype;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetConnection.prototype, "connectedProxyType", {
+        get: function () {
+            release || notImplemented('public flash.net.NetConnection::get connectedProxyType');
+            return this._connectedProxyType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetConnection.prototype, "usingTLS", {
+        get: function () {
+            return this._usingTLS;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetConnection.prototype, "protocol", {
+        get: function () {
+            return this._protocol;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetConnection.prototype, "maxPeerConnections", {
+        get: function () {
+            release || notImplemented('public flash.net.NetConnection::get maxPeerConnections');
+            return this._maxPeerConnections;
+        },
+        set: function (maxPeers /*uint*/) {
+            maxPeers = maxPeers >>> 0;
+            release || notImplemented('public flash.net.NetConnection::set maxPeerConnections');
+            this._maxPeerConnections = maxPeers;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetConnection.prototype, "nearID", {
+        get: function () {
+            release || notImplemented('public flash.net.NetConnection::get nearID');
+            return this._nearID;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetConnection.prototype, "farID", {
+        get: function () {
+            release || notImplemented('public flash.net.NetConnection::get farID');
+            return this._farID;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetConnection.prototype, "nearNonce", {
+        get: function () {
+            release || notImplemented('public flash.net.NetConnection::get nearNonce');
+            return this._nearNonce;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetConnection.prototype, "farNonce", {
+        get: function () {
+            release || notImplemented('public flash.net.NetConnection::get farNonce');
+            return this._farNonce;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetConnection.prototype, "unconnectedPeerStreams", {
+        get: function () {
+            release || notImplemented('public flash.net.NetConnection::get unconnectedPeerStreams');
+            return this._unconnectedPeerStreams;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    NetConnection.prototype.invoke = function (index /*uint*/) {
+        index = index >>> 0;
+        return this._invoke(index, Array.prototype.slice.call(arguments, 1));
+    };
+    NetConnection.prototype._invoke = function (index, args) {
+        var simulated = false;
+        var result;
+        switch (index) {
+            case 1: // close
+            case 2: // call, e.g. with ('createStream', <Responder>)
+                simulated = true;
+                break;
+        }
+        (simulated ? somewhatImplemented : notImplemented)('private flash.net.NetConnection::_invoke (' + index + ')');
+        return result;
+    };
+    // Called whenever the class is initialized.
+    NetConnection.classInitializer = null;
+    /* ------------------------------------------------------------------------------------
+     * Flash Remoting (AMF over HTTP POST) — the transport used by Zend_Amf / AMFPHP / etc.
+     * Serialisation is delegated to the AVM2 ByteArray AMF codec so arguments and results
+     * stay proper AVM2 objects; only the remoting packet envelope is hand-written here.
+     * ---------------------------------------------------------------------------------- */
+    NetConnection._netStatusEventClass = null;
+    NetConnection._byteArrayClass = null;
+    // AS -> JS Bindings
+    NetConnection._defaultObjectEncoding = 3 /* AMF3 */;
+    return NetConnection;
+}(EventDispatcher));
+export { NetConnection };

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

@@ -0,0 +1,30 @@
+import { ASFunction, ASObject } from '@awayfl/avm2';
+/**
+ * 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.
+ */
+export declare class Responder extends ASObject {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    constructor(result: ASFunction, status?: ASFunction);
+    private _result;
+    private _status;
+    ctor(result: ASFunction, status: ASFunction): void;
+    /** Internal: invoke the result callback (used by NetConnection HTTP/AMF remoting). */
+    invokeResult(value: any): void;
+    /** Internal: invoke the status/fault callback (used by NetConnection HTTP/AMF remoting). */
+    invokeStatus(value: any): void;
+}
+//# sourceMappingURL=Responder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Responder.d.ts","sourceRoot":"","sources":["../../../lib/net/Responder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACpD;;;;;;;;;;;;;;GAcG;AAGH,qBAAa,SAAU,SAAQ,QAAQ;IAGtC,MAAM,CAAC,gBAAgB,EAAE,GAAG,CAAQ;IAGpC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAG,CAAQ;IAGtC,MAAM,CAAC,eAAe,EAAE,MAAM,EAAG,CAAQ;gBAE5B,MAAM,EAAE,UAAU,EAAE,MAAM,GAAE,UAAiB;IAI1D,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,OAAO,CAAa;IAM5B,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI;IAKlD,sFAAsF;IACtF,YAAY,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI;IAK9B,4FAA4F;IAC5F,YAAY,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI;CAI9B"}

package/dist/lib/net/Responder.js

@@ -0,0 +1,49 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+/**
+ * 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.
+ */
+// Class: Responder
+var Responder = /** @class */ (function (_super) {
+    __extends(Responder, _super);
+    function Responder(result, status) {
+        if (status === void 0) { status = null; }
+        return _super.call(this) || this;
+    }
+    // JS -> AS Bindings
+    // AS -> JS Bindings
+    Responder.prototype.ctor = function (result, status) {
+        this._result = result;
+        this._status = status;
+    };
+    /** Internal: invoke the result callback (used by NetConnection HTTP/AMF remoting). */
+    Responder.prototype.invokeResult = function (value) {
+        if (this._result)
+            this._result.axApply(null, [value]);
+    };
+    /** Internal: invoke the status/fault callback (used by NetConnection HTTP/AMF remoting). */
+    Responder.prototype.invokeStatus = function (value) {
+        if (this._status)
+            this._status.axApply(null, [value]);
+    };
+    // Called whenever the class is initialized.
+    Responder.classInitializer = null;
+    // List of static symbols to link.
+    Responder.classSymbols = null; // [];
+    // List of instance symbols to link.
+    Responder.instanceSymbols = null; // [];
+    return Responder;
+}(ASObject));
+export { Responder };

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

@@ -0,0 +1,66 @@
+import { ASObject } from '@awayfl/avm2';
+export declare const AWAY_SO_VERSION = 3;
+export declare const AWAY_SO_MAGIC = "AWAY";
+export declare const AWAY_SO_HEADER_SIZE: number;
+interface IStorage {
+    getItem(key: string): string;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+export declare function getSharedObjectStorage(): IStorage;
+export declare class SharedObjectDebug {
+    static _lastRawData: any;
+    static _lastDecodedData: any;
+    static decodedData(): {};
+    static encodeAndApplyData(): any;
+}
+export declare class SharedObject extends ASObject {
+    awaySOVersion: number;
+    private _data;
+    private _object_name;
+    static axClass: typeof SharedObject;
+    static _sharedObjects: Record<string, SharedObject>;
+    constructor();
+    static get defaultObjectEncoding(): number;
+    static set defaultObjectEncoding(version: number);
+    static deleteAll(url: string): number;
+    static getDiskUsage(url: string): number;
+    _path: string;
+    _fps: number;
+    _objectEncoding: any;
+    private static _defaultObjectEncoding;
+    static tryDecodeData(data: string): {
+        data: any;
+        version: number;
+    };
+    static tryEncodeData(data: any): string;
+    static getLocal(name: string, localPath?: string, secure?: boolean): SharedObject;
+    static getRemote(name: string, remotePath?: string, persistence?: boolean, secure?: boolean): SharedObject;
+    static closeAll(): void;
+    static flushAll(): void;
+    flush(minDiskSpace?: number): void;
+    get data(): ASObject;
+    set data(object: ASObject);
+    get objectEncoding(): number;
+    set objectEncoding(version: number);
+    get client(): ASObject;
+    set client(object: ASObject);
+    setDirty(propertyName: string): void;
+    connect(myConnection: any, params?: string): void;
+    send(): void;
+    /**
+     * Closed and flushed SO
+     * @see https://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/SharedObject.html#close()
+     */
+    close(): void;
+    /**
+     * Clear object
+     * @see https://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/SharedObject.html#clear()
+     */
+    clear(): void;
+    get size(): number;
+    set fps(updatesPerSecond: number);
+    setProperty(propertyName: string, value?: any): void;
+}
+export {};
+//# sourceMappingURL=SharedObject.d.ts.map