@swf2es/player-hosts 0.1.6 → 0.1.7

package/dist/thread/player/playerglobal/flash/net/NetConnection.js

@@ -1,9 +1,13 @@
 // flash.net.NetConnection in its local mode, connect(null), which Flash
 // keeps for progressive video, with its properties and status events as
-// Flash gives them; an HTTP URI is kept, as Flash Remoting would use it,
-// and a call over it is not supported yet. Responder holds its callbacks.
+// Flash gives them; and Flash Remoting over an HTTP URI: each call queued,
+// and a frame's calls POSTed together at its end as one packet
+// (remoting.ts), the connection's headers with them, each answer, /n/
+// onResult or /n/onStatus, going to its Responder, as adl does.
+// Responder holds its callbacks.
 import { avm2 } from "../../../../runtime/index.js";
 import { dispatchEvent } from "../../../scripting/events.js";
+import { remoteArguments, remoteMessages, remotePacket, remoteValue, } from "./remoting.js";
 /** NetConnection's private invoke codes, as playerglobal's constants have them. */
 const CLOSE = 1;
 const CALL = 2;
@@ -32,8 +36,10 @@ export function netConnectionNatives(s) {
         /** Null is the local connection, at once and connected; an HTTP URI is only kept. A connection made goes first. */
         connect(command) {
             const self = this;
-            if (this.$connected) {
+            // A gateway connected before is closed as a local one is (the corpus's netconnection_send_remote).
+            if (this.$connected || this.$remote) {
                 this.$connected = false;
+                this.$remote = null;
                 status(self, ["code", "NetConnection.Connect.Closed", "level", "status"]);
             }
             if (command === null || command === undefined || s.rt.toString(command) === "null") {
@@ -43,6 +49,16 @@ export function netConnectionNatives(s) {
                 return;
             }
             this.$uri = s.rt.toString(command);
+            if (/^https?:\/\//i.test(this.$uri)) {
+                this.$remote = {
+                    url: this.$uri,
+                    headers: [],
+                    queue: [],
+                    next: 1,
+                    responders: new Map(),
+                    scheduled: false,
+                };
+            }
         }
         "flash.net:NetConnection::invoke"(code) {
             if (s.rt.toUint(code) === CLOSE) {
@@ -51,13 +67,16 @@ export function netConnectionNatives(s) {
             }
             throw s.rt.unsupported(`NetConnection invoke ${s.rt.toUint(code)}`);
         }
-        "flash.net:NetConnection::invokeWithArgsArray"(code, _args) {
+        "flash.net:NetConnection::invokeWithArgsArray"(code, args) {
             const which = s.rt.toUint(code);
+            const values = (args?.$a ?? []);
             if (which === ADD_HEADER) {
+                addHeader(this, values);
                 return undefined;
             }
             if (which === CALL) {
-                throw s.rt.unsupported("NetConnection.call, Flash Remoting");
+                call(this, values);
+                return undefined;
             }
             throw s.rt.unsupported(`NetConnection invoke ${which}`);
         }
@@ -135,6 +154,7 @@ export function netConnectionNatives(s) {
         const wasConnected = o.$connected ?? false;
         o.$connected = false;
         o.$uri = null;
+        o.$remote = null;
         if (wasConnected) {
             status(o, ["code", "NetConnection.Connect.Closed", "level", "status"]);
         }
@@ -143,6 +163,131 @@ export function netConnectionNatives(s) {
             status(o, ["code", "", "description", "", "details", "", "level", "status"]);
         }
     };
+    /**
+     * A call queued for the frame's end, numbered on its connection; nothing
+     * on a local connection or none, which send nothing, as in adl.
+     */
+    const call = (o, values) => {
+        const remote = o.$remote;
+        if (!remote) {
+            return;
+        }
+        const method = s.rt.toString(values[0]);
+        const responder = (values[1] ?? null);
+        const id = remote.next++;
+        const encoding = o.$objectEncoding ?? defaultEncoding;
+        remote.queue.push({ method, id, body: remoteArguments(s.rt, values.slice(2), encoding) });
+        remote.responders.set(id, responder);
+        if (!remote.scheduled) {
+            remote.scheduled = true;
+            s.afterExitFrame.push(() => send(o, remote, encoding));
+        }
+    };
+    /** One header of a name, its case aside: the last set, a value of null its value (corpus). */
+    const addHeader = (o, values) => {
+        const remote = o.$remote;
+        if (!remote) {
+            return;
+        }
+        const name = s.rt.toString(values[0]);
+        const encoding = o.$objectEncoding ?? defaultEncoding;
+        const value = remoteValue(s.rt, values[2] ?? null, encoding);
+        remote.headers = remote.headers.filter((h) => h.name.toLowerCase() !== name.toLowerCase());
+        remote.headers.push({ name, mustUnderstand: s.rt.toBoolean(values[1]), value });
+    };
+    /** The frame's calls, POSTed as one packet; their answers come in a later frame. */
+    const send = (o, remote, encoding) => {
+        remote.scheduled = false;
+        const calls = remote.queue;
+        remote.queue = [];
+        const fetch = s.fetch;
+        // A connection closed or replaced since sends nothing.
+        if (o.$remote !== remote || calls.length === 0 || !fetch) {
+            return;
+        }
+        const body = remotePacket(encoding, remote.headers, calls);
+        const request = fetch({
+            url: remote.url,
+            method: "POST",
+            headers: [["Content-Type", "application/x-amf"]],
+            body,
+            purpose: "data",
+        }, new AbortController().signal).then((result) => result, () => ({ bytes: null, status: 0, headers: [] }));
+        s.loads.trackRequest(request.then((result) => {
+            s.loads.deferHostEvent(() => {
+                try {
+                    answered(o, remote, result.bytes, result.status);
+                }
+                finally {
+                    // Its calls are done with, answered or not: their responders go.
+                    for (const call of calls) {
+                        remote.responders.delete(call.id);
+                    }
+                }
+            });
+        }));
+    };
+    /**
+     * An answer: each message to the responder of the call it names; an
+     * HTTP error or no answer as Call.Failed, one that is no packet as
+     * Call.BadVersion, an empty one as nothing, as adl reports them.
+     */
+    const answered = (o, remote, bytes, httpStatus) => {
+        if (o.$remote !== remote) {
+            return;
+        }
+        if (bytes === null) {
+            const description = httpStatus >= 300 ? `HTTP: Status ${httpStatus}` : "HTTP: Failed";
+            status(o, [
+                "code",
+                "NetConnection.Call.Failed",
+                "description",
+                description,
+                "details",
+                remote.url,
+                "level",
+                "error",
+            ]);
+            return;
+        }
+        if (bytes.length === 0) {
+            return;
+        }
+        const messages = remoteMessages(s.rt, bytes);
+        if (messages === "version") {
+            status(o, [
+                "code",
+                "NetConnection.Call.BadVersion",
+                "description",
+                "",
+                "details",
+                "",
+                "level",
+                "error",
+            ]);
+            return;
+        }
+        for (const [target, value] of messages) {
+            const m = /^\/(\d+)\/(onResult|onStatus)$/.exec(target);
+            if (!m) {
+                continue;
+            }
+            const id = Number(m[1]);
+            const responder = remote.responders.get(id);
+            remote.responders.delete(id);
+            const handler = responder
+                ? responder[m[2] === "onResult" ? "$result" : "$status"]
+                : null;
+            if (typeof handler === "function" || (handler && typeof handler === "object")) {
+                try {
+                    s.rt.call(handler, null, value);
+                }
+                catch (error) {
+                    s.reportUncaught(error);
+                }
+            }
+        }
+    };
     class ResponderNatives {
         "flash.net:Responder::ctor"(result, status) {
             this.$result = result;

package/dist/thread/player/playerglobal/flash/net/local-values.js

@@ -6,12 +6,29 @@ import * as A from "../../../avm1/amf.js";
 import { LOCAL_MESSAGE_LIMIT } from "../../../localconnection.js";
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
-export function writeLocalValues(rt, args) {
-    // The original AMF3 payload is already bounded; AMF0 can expand small integers.
-    const out = new A.Writer(() => null, 8, null, null);
-    const references = new Map();
-    let next = 1;
-    const write = (value, depth) => {
+/**
+ * AS3 values as AMF0, through the AS2 codec's writer: LocalConnection's
+ * arguments, and Flash Remoting's in AMF0. `limit` bounds strings and
+ * arrays (LocalConnection's message size); `next` is the reference the
+ * first object takes: 1 where the strict array of arguments is itself the
+ * first, as LocalConnection numbers them, 0 for remoting's (adl).
+ */
+export class Amf0Writer {
+    rt;
+    limit;
+    next;
+    what;
+    out = new A.Writer(() => null, 8, null, null);
+    references = new Map();
+    constructor(rt, limit = LOCAL_MESSAGE_LIMIT, next = 1, what = "LocalConnection") {
+        this.rt = rt;
+        this.limit = limit;
+        this.next = next;
+        this.what = what;
+    }
+    value(value, depth = 0) {
+        const out = this.out;
+        const rt = this.rt;
         if (depth >= A.MAX_DEPTH - 2) {
             out.bytes(A.UNDEFINED);
             return;
@@ -37,8 +54,8 @@ export function writeLocalValues(rt, args) {
         }
         if (traits.name === "XML" || traits.name === "flash.xml::XMLDocument") {
             const text = rt.toString(rt.callProperty(value, rt.publicName(traits.name === "XML" ? "toXMLString" : "toString")));
-            if (text.length > LOCAL_MESSAGE_LIMIT) {
-                throw new RangeError("LocalConnection message too large");
+            if (text.length > this.limit) {
+                throw new RangeError(`${this.what} message too large`);
             }
             const bytes = encoder.encode(text);
             out.bytes(A.XML);
@@ -46,13 +63,13 @@ export function writeLocalValues(rt, args) {
             out.push(bytes);
             return;
         }
-        const seen = references.get(value);
+        const seen = this.references.get(value);
         if (seen !== undefined) {
             out.bytes(A.REFERENCE);
             out.u16(seen);
             return;
         }
-        references.set(value, next++);
+        this.references.set(value, this.next++);
         if (value.$a) {
             const array = value.$a;
             const properties = value.$d;
@@ -61,22 +78,22 @@ export function writeLocalValues(rt, args) {
                 out.u32(array.length);
                 for (const key of Object.keys(array)) {
                     out.name(key);
-                    write(array[Number(key)], depth + 1);
+                    this.value(array[Number(key)], depth + 1);
                 }
                 for (const [key, field] of properties) {
                     out.name(key);
-                    write(field, depth + 1);
+                    this.value(field, depth + 1);
                 }
                 out.bytes(0, 0, A.OBJECT_END);
                 return;
             }
-            if (array.length > LOCAL_MESSAGE_LIMIT) {
-                throw new RangeError("LocalConnection message too large");
+            if (array.length > this.limit) {
+                throw new RangeError(`${this.what} message too large`);
             }
             out.bytes(A.STRICT_ARRAY);
             out.u32(array.length);
             for (let i = 0; i < array.length; i++) {
-                write(array[i], depth + 1);
+                this.value(array[i], depth + 1);
             }
             return;
         }
@@ -106,80 +123,122 @@ export function writeLocalValues(rt, args) {
                 continue;
             }
             out.name(name);
-            write(field, depth + 1);
+            this.value(field, depth + 1);
         }
         out.bytes(0, 0, A.OBJECT_END);
-    };
-    out.bytes(A.STRICT_ARRAY);
-    out.u32(args.length);
+    }
+}
+export function writeLocalValues(rt, args) {
+    // The original AMF3 payload is already bounded; AMF0 can expand small integers.
+    const w = new Amf0Writer(rt);
+    w.out.bytes(A.STRICT_ARRAY);
+    w.out.u32(args.length);
     for (const value of args) {
-        write(value, 0);
+        w.value(value);
     }
-    return out.finish();
+    return w.out.finish();
 }
-export function readLocalValues(rt, bytes) {
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const references = [];
-    let at = 0;
-    const u16 = () => {
-        const n = view.getUint16(at);
-        at += 2;
+/** AMF0's marker for an AMF3 value after it, which Flash Remoting writes and reads. */
+export const AVMPLUS = 0x11;
+/**
+ * AMF0 read as AS3 values from `at`: LocalConnection's arguments, and
+ * Flash Remoting's answers, whose AMF3 values after 0x11 (with `amf3`)
+ * share one AMF3 reader's tables.
+ */
+export class Amf0Reader {
+    rt;
+    bytes;
+    amf3;
+    what;
+    at;
+    view;
+    references = [];
+    amf3Reader = null;
+    amf3Bytes = null;
+    constructor(rt, bytes, at = 0, amf3 = false, what = "LocalConnection") {
+        this.rt = rt;
+        this.bytes = bytes;
+        this.amf3 = amf3;
+        this.what = what;
+        this.at = at;
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+    u16() {
+        const n = this.view.getUint16(this.at);
+        this.at += 2;
         return n;
-    };
-    const u32 = () => {
-        const n = view.getUint32(at);
-        at += 4;
+    }
+    u32() {
+        const n = this.view.getUint32(this.at);
+        this.at += 4;
         return n;
-    };
-    const utf = (length) => {
-        if (length > bytes.length - at) {
-            throw new RangeError("LocalConnection message ended early");
+    }
+    utf(length) {
+        if (length > this.bytes.length - this.at) {
+            throw new RangeError(`${this.what} message ended early`);
         }
-        const text = decoder.decode(bytes.subarray(at, at + length));
-        at += length;
+        const text = decoder.decode(this.bytes.subarray(this.at, this.at + length));
+        this.at += length;
         return text;
-    };
-    const name = () => utf(u16());
-    const read = (depth) => {
+    }
+    name() {
+        return this.utf(this.u16());
+    }
+    /** An AMF3 value at the reader's place, its tables those of the values before it. */
+    amf3Value() {
+        if (this.amf3Bytes === null) {
+            this.amf3Bytes = new avm2.Bytes(this.rt, {});
+            this.amf3Bytes.write(this.bytes);
+            this.amf3Reader = new avm2.Amf3Reader(this.rt, this.amf3Bytes);
+        }
+        this.amf3Bytes.position = this.at;
+        const value = this.amf3Reader.value();
+        this.at = this.amf3Bytes.position;
+        return value;
+    }
+    value(depth = 0) {
+        const rt = this.rt;
+        const bytes = this.bytes;
+        const view = this.view;
         if (depth >= A.MAX_DEPTH) {
-            throw new RangeError("LocalConnection arguments nested too deeply");
+            throw new RangeError(`${this.what} arguments nested too deeply`);
         }
-        const marker = bytes[at++];
+        const marker = bytes[this.at++];
         switch (marker) {
             case A.NUMBER: {
-                const n = view.getFloat64(at);
-                at += 8;
+                const n = view.getFloat64(this.at);
+                this.at += 8;
                 return n;
             }
             case A.BOOLEAN:
-                return bytes[at++] !== 0;
+                return bytes[this.at++] !== 0;
             case A.STRING:
-                return name();
+                return this.name();
             case A.LONG_STRING:
-                return utf(u32());
+                return this.utf(this.u32());
             case A.NULL:
                 return null;
             case A.UNDEFINED:
             case A.UNSUPPORTED:
                 return undefined;
             case A.REFERENCE:
-                return references[u16()];
+                return this.references[this.u16()];
             case A.DATE: {
-                const time = view.getFloat64(at);
-                at += 10;
+                const time = view.getFloat64(this.at);
+                this.at += 10;
                 return rt.construct(rt.classNamed("Date"), time);
             }
             case A.XML:
-                return rt.construct(rt.classNamed("flash.xml::XMLDocument"), utf(u32()));
+                return rt.construct(rt.classNamed("flash.xml::XMLDocument"), this.utf(this.u32()));
             case A.STRICT_ARRAY: {
-                const count = u32();
-                if (count > bytes.length - at) {
-                    throw new RangeError("LocalConnection message ended early");
+                const count = this.u32();
+                if (count > bytes.length - this.at) {
+                    throw new RangeError(`${this.what} message ended early`);
                 }
                 const result = rt.newArray([]);
-                references.push(result);
+                this.references.push(result);
                 for (let i = 0; i < count; i++) {
-                    result.$a.push(read(depth + 1));
+                    result.$a.push(this.value(depth + 1));
                 }
                 return result;
             }
@@ -188,30 +247,37 @@ export function readLocalValues(rt, bytes) {
             case A.ECMA_ARRAY: {
                 let result;
                 if (marker === A.TYPED_OBJECT) {
-                    result = rt.allocate(rt.classByAlias(name(), true)) ?? rt.newObject([]);
+                    result = rt.allocate(rt.classByAlias(this.name(), true)) ?? rt.newObject([]);
                 }
                 else {
                     result = marker === A.ECMA_ARRAY ? rt.newArray([]) : rt.newObject([]);
                 }
-                const length = marker === A.ECMA_ARRAY ? u32() : 0;
-                references.push(result);
+                const length = marker === A.ECMA_ARRAY ? this.u32() : 0;
+                this.references.push(result);
                 for (;;) {
-                    const key = name();
-                    if (key === "" && bytes[at] === A.OBJECT_END) {
-                        at++;
+                    const key = this.name();
+                    if (key === "" && bytes[this.at] === A.OBJECT_END) {
+                        this.at++;
                         break;
                     }
-                    rt.setProperty(result, rt.publicName(key), read(depth + 1));
+                    rt.setProperty(result, rt.publicName(key), this.value(depth + 1));
                 }
                 if (marker === A.ECMA_ARRAY && length > result.$a.length) {
                     result.$a.length = length;
                 }
                 return result;
             }
+            case AVMPLUS:
+                if (this.amf3) {
+                    return this.amf3Value();
+                }
+                throw new RangeError(`Invalid ${this.what} AMF0 marker`);
             default:
-                throw new RangeError("Invalid LocalConnection AMF0 marker");
+                throw new RangeError(`Invalid ${this.what} AMF0 marker`);
         }
-    };
-    const result = read(0);
+    }
+}
+export function readLocalValues(rt, bytes) {
+    const result = new Amf0Reader(rt, bytes).value();
     return result.$a;
 }

package/dist/thread/player/playerglobal/flash/net/remoting.js

@@ -0,0 +1,162 @@
+// Flash Remoting's packets for AS3's NetConnection.call, as adl sends and
+// reads them. A packet is its version (0, or 3 where the connection's
+// objectEncoding is AMF3), its headers and its calls, each call's
+// arguments a strict array. In AMF0 every value is AMF0, the arguments
+// sharing one table of references whose first object is 0. In AMF3 the
+// strings, numbers, booleans, null and undefined are still AMF0, and every
+// other value is AMF0's 0x11 followed by AMF3, the arguments of a call
+// sharing one AMF3 writer's tables; a header's value is one of its own.
+import { avm2 } from "../../../../runtime/index.js";
+import * as A from "../../../avm1/amf.js";
+import { Amf0Reader, Amf0Writer, AVMPLUS } from "./local-values.js";
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/** Whether AMF3 writes `v` as AMF0 all the same: what has no AMF3 reference to share. */
+function primitive(v) {
+    return (v === null || (typeof v !== "object" && typeof v !== "function") || v instanceof avm2.FloatValue);
+}
+/** `v`, a primitive, in AMF0 at the end of `out`. */
+function writeAmf0Primitive(out, v) {
+    const w = new A.Writer(() => null, 8, null, null);
+    w.value(v instanceof avm2.FloatValue ? v.value : v);
+    out.write(w.finish());
+}
+/** AMF3 values, each after 0x11, into one buffer, sharing one AMF3 writer's tables. */
+class Amf3Values {
+    bytes;
+    writer;
+    constructor(rt) {
+        this.bytes = new avm2.Bytes(rt, {});
+        this.writer = new avm2.Amf3Writer(rt, this.bytes);
+    }
+    value(v) {
+        if (primitive(v)) {
+            writeAmf0Primitive(this.bytes, v);
+            return;
+        }
+        this.bytes.write(Uint8Array.of(AVMPLUS));
+        this.writer.value(v);
+    }
+    finish() {
+        return this.bytes.buffer.slice(0, this.bytes.length);
+    }
+}
+/** A header's value: AMF0, itself its table's first object; or in AMF3, with tables of its own. */
+export function remoteValue(rt, v, encoding) {
+    if (encoding === 3) {
+        const w = new Amf3Values(rt);
+        w.value(v);
+        return w.finish();
+    }
+    const w = new Amf0Writer(rt, Number.POSITIVE_INFINITY, 0, "Remoting");
+    w.value(v);
+    return w.out.finish();
+}
+/** A call's arguments: a strict array of them, in the connection's encoding. */
+export function remoteArguments(rt, args, encoding) {
+    if (encoding === 3) {
+        const w = new Amf3Values(rt);
+        const head = new Uint8Array(5);
+        head[0] = A.STRICT_ARRAY;
+        new DataView(head.buffer).setUint32(1, args.length);
+        w.bytes.write(head);
+        for (const v of args) {
+            w.value(v);
+        }
+        return w.finish();
+    }
+    const w = new Amf0Writer(rt, Number.POSITIVE_INFINITY, 0, "Remoting");
+    w.out.bytes(A.STRICT_ARRAY);
+    w.out.u32(args.length);
+    for (const v of args) {
+        w.value(v);
+    }
+    return w.out.finish();
+}
+/** Bytes, joined once. */
+function join(chunks) {
+    let length = 0;
+    for (const chunk of chunks) {
+        length += chunk.length;
+    }
+    const out = new Uint8Array(length);
+    let at = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, at);
+        at += chunk.length;
+    }
+    return out;
+}
+/** A u16-long UTF-8 string, no marker. */
+function utf(text) {
+    const b = encoder.encode(text).subarray(0, 0xffff);
+    return join([Uint8Array.of(b.length >> 8, b.length & 0xff), b]);
+}
+const u16 = (n) => Uint8Array.of((n >> 8) & 0xff, n & 0xff);
+const u32 = (n) => Uint8Array.of((n >>> 24) & 0xff, (n >>> 16) & 0xff, (n >>> 8) & 0xff, n & 0xff);
+/** A packet of the calls, each answered at /n, its number on the connection. */
+export function remotePacket(encoding, headers, calls) {
+    const out = [u16(encoding === 3 ? 3 : 0), u16(headers.length)];
+    for (const h of headers) {
+        out.push(utf(h.name), Uint8Array.of(h.mustUnderstand ? 1 : 0), u32(h.value.length), h.value);
+    }
+    out.push(u16(calls.length));
+    for (const call of calls) {
+        out.push(utf(call.method), utf(`/${call.id}`), u32(call.body.length), call.body);
+    }
+    return join(out);
+}
+/**
+ * An answer's messages, their targets and values; "version" for one that
+ * is no packet of version 0 or 3, which Flash reports as BadVersion.
+ * Each value is read on its own, AMF3 after 0x11 included; a message's
+ * length, where it gives one, says where the next begins.
+ */
+export function remoteMessages(rt, bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    try {
+        const version = view.getUint16(0);
+        if (version !== 0 && version !== 3) {
+            return "version";
+        }
+        let at = 2;
+        const text = () => {
+            const n = view.getUint16(at);
+            at += 2;
+            if (at + n > bytes.length) {
+                throw new RangeError("past the end");
+            }
+            const s = decoder.decode(bytes.subarray(at, at + n));
+            at += n;
+            return s;
+        };
+        const value = () => {
+            const length = view.getUint32(at);
+            at += 4;
+            const start = at;
+            const reader = new Amf0Reader(rt, bytes, at, true, "Remoting");
+            const v = reader.value();
+            at = length !== 0xffffffff && start + length <= bytes.length ? start + length : reader.at;
+            return v;
+        };
+        const headers = view.getUint16(at);
+        at += 2;
+        for (let i = 0; i < headers; i++) {
+            text();
+            at += 1;
+            value();
+        }
+        const count = view.getUint16(at);
+        at += 2;
+        const messages = [];
+        for (let i = 0; i < count; i++) {
+            const target = text();
+            text();
+            messages.push([target, value()]);
+        }
+        return messages;
+    }
+    catch {
+        return "version";
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swf2es/player-hosts",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Optional Node and WebSocket transports, worker threads, an IndexedDB module cache and precompiled modules for the swf2es player",
   "keywords": [
     "swf",
@@ -60,6 +60,6 @@
     "LICENSE.third-party"
   ],
   "dependencies": {
-    "@swf2es/player": "0.1.6"
+    "@swf2es/player": "0.1.7"
   }
 }