@swf2es/player-hosts 0.1.5 → 0.1.6

package/dist/thread/player/display/bounds.js

@@ -25,6 +25,7 @@ export function ownBounds(d, lines) {
             : null;
     }
     if (d instanceof TextObject) {
+        d.settle();
         return { xMin: d.left, yMin: d.top, xMax: d.left + d.width, yMax: d.top + d.height };
     }
     if (d instanceof VideoObject) {
@@ -95,12 +96,116 @@ export function placedRect(d, r, drawn = false) {
     const box = transformRect(r, own);
     return back ? boxThrough(box, back) : box;
 }
+// Scratch matrices for boundsIn's flat case: getRect and getBounds are asked of every moved
+// sprite, every frame, by some movies, and these leave nothing behind for the collector.
+const scratchUp = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+const scratchDown = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+const scratchBoth = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+/** `m` set to `p`'s six numbers. */
+function copyInto(m, p) {
+    m.a = p.a;
+    m.b = p.b;
+    m.c = p.c;
+    m.d = p.d;
+    m.tx = p.tx;
+    m.ty = p.ty;
+}
+/** `m` then `p` into `out`, as concat multiplies two flat matrices; `out` may be `m`. */
+function concatInto(out, m, p) {
+    const a = m.a * p.a + m.b * p.c;
+    const b = m.a * p.b + m.b * p.d;
+    const c = m.c * p.a + m.d * p.c;
+    const d = m.c * p.b + m.d * p.d;
+    const tx = m.tx * p.a + m.ty * p.c + p.tx;
+    const ty = m.tx * p.b + m.ty * p.d + p.ty;
+    out.a = a;
+    out.b = b;
+    out.c = c;
+    out.d = d;
+    out.tx = tx;
+    out.ty = ty;
+}
+// `placed` of one with a scrollRect, shifted as geometry's shifted shifts it, without a new matrix.
+const scratchPlaced = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+/** `d.placed` if flat, into scratchPlaced where a scroll shifts it; null for a projective one. */
+function flatPlaced(d) {
+    if (d.space) {
+        const m = d.placed;
+        return isProjective(m) ? null : m;
+    }
+    const m = d.matrix;
+    if (isProjective(m)) {
+        return null;
+    }
+    const r = d.scroll;
+    if (!r) {
+        return m;
+    }
+    copyInto(scratchPlaced, m);
+    scratchPlaced.tx = m.tx - m.a * r.xMin - m.c * r.yMin;
+    scratchPlaced.ty = m.ty - m.b * r.xMin - m.d * r.yMin;
+    return scratchPlaced;
+}
+/** toStage into `out`, if every matrix on the way is flat; false, `out` spoilt, otherwise. */
+function flatToStage(d, stage, out) {
+    const own = flatPlaced(d);
+    if (!own) {
+        return false;
+    }
+    copyInto(out, own);
+    for (let p = d.parent; p && p !== stage; p = p.parent) {
+        const m = flatPlaced(p);
+        if (!m) {
+            return false;
+        }
+        concatInto(out, out, m);
+    }
+    return true;
+}
+/** `m` inverted in place, as invert does; left as it is, as invert's null is, when flat. */
+function invertFlat(m) {
+    const det = m.a * m.d - m.b * m.c;
+    if (det === 0) {
+        return false;
+    }
+    const a = m.d / det;
+    const b = -m.b / det;
+    const c = -m.c / det;
+    const d = m.a / det;
+    const tx = (m.c * m.ty - m.d * m.tx) / det;
+    const ty = (m.b * m.tx - m.a * m.ty) / det;
+    m.a = a;
+    m.b = b;
+    m.c = c;
+    m.d = d;
+    m.tx = tx;
+    m.ty = ty;
+    return true;
+}
 /** `d`'s bounds in `target`'s space (its own for null), through the stage. */
 export function boundsIn(d, target, stage, lines) {
     const own = bounds(d, lines) ?? { xMin: 0, yMin: 0, xMax: 0, yMax: 0 };
     if (!target || target === d) {
         return own;
     }
+    // Flat all the way, the common case, the same arithmetic as below's in scratch matrices.
+    if (flatToStage(d, stage, scratchUp)) {
+        if (target === stage) {
+            copyInto(scratchDown, IDENTITY);
+        }
+        else if (!flatToStage(target, stage, scratchDown)) {
+            return boundsInThrough(d, target, stage, own);
+        }
+        else if (!invertFlat(scratchDown)) {
+            copyInto(scratchDown, IDENTITY);
+        }
+        concatInto(scratchBoth, scratchUp, scratchDown);
+        return transformRect(own, scratchBoth);
+    }
+    return boundsInThrough(d, target, stage, own);
+}
+/** boundsIn where a plane is on the way: up or down through a projective matrix. */
+function boundsInThrough(d, target, stage, own) {
     const up = toStage(d, stage);
     const down = target === stage ? IDENTITY : (invert(toStage(target, stage)) ?? IDENTITY);
     if (!isProjective(up)) {

package/dist/thread/player/display/drawing.js

@@ -20,6 +20,13 @@ function fillsOnly(layer) {
 const LINE_POINTS = [0, 0];
 const CURVE_POINTS = [0, 0, 0, 0];
 const CUBIC_POINTS = [0, 0, 0, 0, 0, 0];
+// Each quarter's start and end directions, (sx, sy) and (ex, ey), for arc.
+const QUARTERS = [
+    [1, 0, 0, 1],
+    [0, 1, -1, 0],
+    [-1, 0, 0, -1],
+    [0, -1, 1, 0],
+];
 /** `kind` and `points` onto the last of `paths`. */
 function append(paths, kind, points) {
     const path = paths[paths.length - 1];
@@ -40,8 +47,13 @@ export class Drawing {
     /** Where the open fill's entries begin in its layer, which fills before it may share. */
     fillStart = 0;
     stroke = null;
-    /** The line closing the open contour, or the one endFill closed, while a line drawn on may take it away. */
+    /**
+     * The stroke whose last closing line closes the open contour, or the one
+     * endFill closed, while a line drawn on may take it away.
+     */
     closing = null;
+    /** The closing line last taken away, for the next: a filled, lined pen makes one a segment. */
+    spareClose = null;
     /**
      * A point of the open contour off its start, for whether it leaves the
      * line through them: its offset from the start, while `heading`.
@@ -205,12 +217,11 @@ export class Drawing {
         if (rx === 0 && ry === 0) {
             return;
         }
-        const [sx, sy, ex, ey] = [
-            [1, 0, 0, 1],
-            [0, 1, -1, 0],
-            [-1, 0, 0, -1],
-            [0, -1, 1, 0],
-        ][quarter];
+        const turn = QUARTERS[quarter];
+        const sx = turn[0];
+        const sy = turn[1];
+        const ex = turn[2];
+        const ey = turn[3];
         this.curveTo(cx + (sx + ex * TAN_22_5) * rx, cy + (sy + ey * TAN_22_5) * ry, cx + (sx + ex) * COS_45 * rx, cy + (sy + ey) * COS_45 * ry);
         this.curveTo(cx + (ex + sx * TAN_22_5) * rx, cy + (ey + sy * TAN_22_5) * ry, cx + ex * rx, cy + ey * ry);
     }
@@ -591,7 +602,7 @@ export class Drawing {
     unclose() {
         if (this.closing) {
             this.version++;
-            this.closing.stroke.closes?.pop();
+            this.spareClose = this.closing.closes?.pop() ?? null;
             this.closing = null;
         }
     }
@@ -603,10 +614,14 @@ export class Drawing {
             return;
         }
         if (contour[1] !== this.x || contour[2] !== this.y) {
-            const close = { at: stroke.paths.length - 1, x: contour[1], y: contour[2] };
+            const close = this.spareClose ?? { at: 0, x: 0, y: 0 };
+            this.spareClose = null;
+            close.at = stroke.paths.length - 1;
+            close.x = contour[1];
+            close.y = contour[2];
             stroke.closes = stroke.closes ?? [];
             stroke.closes.push(close);
-            this.closing = { stroke, close };
+            this.closing = stroke;
             this.version++;
         }
     }

package/dist/thread/player/display/shapes.js

@@ -58,21 +58,60 @@ export function inside(points, px, py) {
     }
     return hit;
 }
+// The running box of extent: one for every call, as bounds are asked of every drawn shape.
+const box = new Float64Array(4);
+function take(x, y) {
+    box[0] = Math.min(box[0], x);
+    box[1] = Math.min(box[1], y);
+    box[2] = Math.max(box[2], x);
+    box[3] = Math.max(box[3], y);
+}
+/** The quadratic curve from (x, y) through (cx, cy) to (ax, ay), at `t`, into the box. */
+function takeCurveAt(t, x, y, cx, cy, ax, ay) {
+    const u = 1 - t;
+    take(u * u * x + 2 * u * t * cx + t * t * ax, u * u * y + 2 * u * t * cy + t * t * ay);
+}
+/** The cubic curve from (x, y) by (c1x, c1y) and (c2x, c2y) to (ax, ay), at `t`, into the box. */
+function takeCubicAt(t, x, y, c1x, c1y, c2x, c2y, ax, ay) {
+    if (!(t > 0 && t < 1)) {
+        return;
+    }
+    const u = 1 - t;
+    take(u * u * u * x + 3 * u * u * t * c1x + 3 * u * t * t * c2x + t * t * t * ax, u * u * u * y + 3 * u * u * t * c1y + 3 * u * t * t * c2y + t * t * t * ay);
+}
+/**
+ * Where the cubic's derivative on one axis, from p0 by c1 and c2 to p3, is
+ * zero within it: the roots of a t² + b t + c, each into the box.
+ */
+function takeCubicTurns(p0, c1, c2, p3, x, y, c1x, c1y, c2x, c2y, ax, ay) {
+    const a = -p0 + 3 * c1 - 3 * c2 + p3;
+    const b = 2 * (p0 - 2 * c1 + c2);
+    const c = c1 - p0;
+    if (a === 0) {
+        if (b !== 0) {
+            takeCubicAt(-c / b, x, y, c1x, c1y, c2x, c2y, ax, ay);
+        }
+        return;
+    }
+    const d = b * b - 4 * a * c;
+    if (d < 0) {
+        return;
+    }
+    const s = Math.sqrt(d);
+    takeCubicAt((-b + s) / (2 * a), x, y, c1x, c1y, c2x, c2y, ax, ay);
+    takeCubicAt((-b - s) / (2 * a), x, y, c1x, c1y, c2x, c2y, ax, ay);
+}
 /**
  * The path's extent, each curve at its true extremes, as [xMin, yMin,
- * xMax, yMax]; null for a path with no points.
+ * xMax, yMax]; null for a path with no points. It allocates only its
+ * answer: the bounds of every shape drawn, a pen's redrawn each frame
+ * among them, are asked again and again.
  */
 export function extent(path) {
-    let xMin = Number.POSITIVE_INFINITY;
-    let yMin = Number.POSITIVE_INFINITY;
-    let xMax = Number.NEGATIVE_INFINITY;
-    let yMax = Number.NEGATIVE_INFINITY;
-    const take = (x, y) => {
-        xMin = Math.min(xMin, x);
-        yMin = Math.min(yMin, y);
-        xMax = Math.max(xMax, x);
-        yMax = Math.max(yMax, y);
-    };
+    box[0] = Number.POSITIVE_INFINITY;
+    box[1] = Number.POSITIVE_INFINITY;
+    box[2] = Number.NEGATIVE_INFINITY;
+    box[3] = Number.NEGATIVE_INFINITY;
     let x = 0;
     let y = 0;
     for (let i = 0; i < path.length;) {
@@ -86,49 +125,36 @@ export function extent(path) {
         }
         take(x, y);
         if (command === CURVE) {
-            const [cx, cy, ax, ay] = path.slice(i + 1, i + 5);
+            const cx = path[i + 1];
+            const cy = path[i + 2];
+            const ax = path[i + 3];
+            const ay = path[i + 4];
             take(ax, ay);
             // Where the derivative is zero on either axis, if within the curve.
-            const at = (t) => {
-                const u = 1 - t;
-                take(u * u * x + 2 * u * t * cx + t * t * ax, u * u * y + 2 * u * t * cy + t * t * ay);
-            };
-            for (const [p0, c, p2] of [
-                [x, cx, ax],
-                [y, cy, ay],
-            ]) {
-                const denominator = p0 - 2 * c + p2;
-                const t = denominator === 0 ? -1 : (p0 - c) / denominator;
-                if (t > 0 && t < 1) {
-                    at(t);
-                }
+            const dx = x - 2 * cx + ax;
+            const tx = dx === 0 ? -1 : (x - cx) / dx;
+            if (tx > 0 && tx < 1) {
+                takeCurveAt(tx, x, y, cx, cy, ax, ay);
+            }
+            const dy = y - 2 * cy + ay;
+            const ty = dy === 0 ? -1 : (y - cy) / dy;
+            if (ty > 0 && ty < 1) {
+                takeCurveAt(ty, x, y, cx, cy, ax, ay);
             }
             x = ax;
             y = ay;
             i += 5;
         }
         else if (command === CUBIC) {
-            const [c1x, c1y, c2x, c2y, ax, ay] = path.slice(i + 1, i + 7);
+            const c1x = path[i + 1];
+            const c1y = path[i + 2];
+            const c2x = path[i + 3];
+            const c2y = path[i + 4];
+            const ax = path[i + 5];
+            const ay = path[i + 6];
             take(ax, ay);
-            const at = (t) => {
-                const u = 1 - t;
-                take(u * u * u * x + 3 * u * u * t * c1x + 3 * u * t * t * c2x + t * t * t * ax, u * u * u * y + 3 * u * u * t * c1y + 3 * u * t * t * c2y + t * t * t * ay);
-            };
-            for (const [p0, c1, c2, p3] of [
-                [x, c1x, c2x, ax],
-                [y, c1y, c2y, ay],
-            ]) {
-                // The derivative's roots: a t² + b t + c = 0.
-                const a = -p0 + 3 * c1 - 3 * c2 + p3;
-                const b = 2 * (p0 - 2 * c1 + c2);
-                const c = c1 - p0;
-                const roots = a === 0 ? (b === 0 ? [] : [-c / b]) : quadraticRoots(a, b, c);
-                for (const t of roots) {
-                    if (t > 0 && t < 1) {
-                        at(t);
-                    }
-                }
-            }
+            takeCubicTurns(x, c1x, c2x, ax, x, y, c1x, c1y, c2x, c2y, ax, ay);
+            takeCubicTurns(y, c1y, c2y, ay, x, y, c1x, c1y, c2x, c2y, ax, ay);
             x = ax;
             y = ay;
             i += 7;
@@ -140,15 +166,7 @@ export function extent(path) {
             i += 3;
         }
     }
-    return xMin <= xMax ? [xMin, yMin, xMax, yMax] : null;
-}
-function quadraticRoots(a, b, c) {
-    const d = b * b - 4 * a * c;
-    if (d < 0) {
-        return [];
-    }
-    const s = Math.sqrt(d);
-    return [(-b + s) / (2 * a), (-b - s) / (2 * a)];
+    return box[0] <= box[2] ? [box[0], box[1], box[2], box[3]] : null;
 }
 /** Layers as they draw mirrored, as of a version: the renderer and the hit tests ask on each redraw. */
 const mirroredLayers = new WeakMap();

package/dist/thread/player/display/textobjects.js

@@ -30,6 +30,15 @@ export class StaticTextObject extends DisplayObject {
         return this.laidGlyphs;
     }
 }
+/** The fields whose fit a set size left pending, for the frame to settle before it is drawn. */
+const pendingFits = new Set();
+/** Every pending fit applied, as Flash applies them before it draws. */
+export function settleFits() {
+    for (const field of pendingFits) {
+        field.settle();
+    }
+    pendingFits.clear();
+}
 /**
  * A TextField: placed by DefineEditText, or made by a script. Its text and
  * formats are a TextModel; a timeline's starts with its tag's text, read
@@ -55,6 +64,12 @@ export class TextObject extends DisplayObject {
     type = "dynamic";
     embedFonts = false;
     autoSize = "none";
+    /**
+     * A script set the size of a field that fits itself: as in Flash, the fit
+     * waits for its size to be asked, its transform to change or the frame to
+     * be drawn, and a wordWrap set meanwhile wraps at the size set (adl).
+     */
+    fitPending = false;
     selectable = true;
     maxChars = 0;
     displayAsPassword = false;
@@ -165,7 +180,7 @@ export class TextObject extends DisplayObject {
      * centre or right edge where it was.
      */
     fit() {
-        if (this.autoSize === "none") {
+        if (this.autoSize === "none" || this.fitPending) {
             return;
         }
         const layout = this.layout;
@@ -186,6 +201,24 @@ export class TextObject extends DisplayObject {
         this.height = height;
         this.invalidate(CONTENT);
     }
+    /** A script set its size: under autoSize, the fit waits (fitPending). */
+    sizeSet() {
+        if (this.autoSize !== "none") {
+            this.fitPending = true;
+            pendingFits.add(this);
+        }
+    }
+    /** The fit a set size left pending, applied: its size asked, its transform changed, the frame drawn. */
+    settle() {
+        if (this.fitPending) {
+            this.fitPending = false;
+            this.fit();
+        }
+    }
+    touch() {
+        super.touch();
+        this.settle();
+    }
     /** The text, \r between its lines. */
     get text() {
         return this.model.text;

package/dist/thread/player/player.js

@@ -10,6 +10,7 @@ import { decodeImages, decodeInBrowser } from "./bitmap/images.js";
 import { drawKernelFrame, drawKernelLetGo, drawKernelUsed } from "./bitmap/kernel.js";
 import { BUTTON, CLIP, Container, MovieClip, OTHER, unloads, walkList, } from "./display/display.js";
 import { setStageSize } from "./display/perspective.js";
+import { settleFits } from "./display/textobjects.js";
 import { readLibrary } from "./display/timeline.js";
 import { customContextMenu } from "./input/context-menu.js";
 import { KeyboardInput } from "./input/keyboard.js";
@@ -607,9 +608,7 @@ export class Player {
             }
         };
         collect(this.stage);
-        for (const orphan of this.scripting?.lifecycle.orphanRoots() ?? []) {
-            collect(orphan);
-        }
+        this.scripting?.lifecycle.eachOrphanRoot(collect);
         // Let go of once advanced, so that the kept list holds none past the tick.
         try {
             for (let i = 0; i < count; i++) {
@@ -624,5 +623,7 @@ export class Player {
             this.scripting.frame(this.stage, true, render);
             this.frameRate = this.scripting.frameRate;
         }
+        // The fits a set size left pending happen before the frame is drawn, as in Flash.
+        settleFits();
     }
 }

package/dist/thread/player/playerglobal/flash/display/DisplayObject.js

@@ -340,7 +340,7 @@ export function displayObjectNatives(s) {
             if (d instanceof TextObject) {
                 d.width = value / (Math.abs(d.scaleX) || 1);
                 d.invalidate(CONTENT);
-                d.fit();
+                d.sizeSet();
                 return;
             }
             const r = bounds(d, true);
@@ -375,7 +375,7 @@ export function displayObjectNatives(s) {
             if (d instanceof TextObject) {
                 d.height = value / (Math.abs(d.scaleY) || 1);
                 d.invalidate(CONTENT);
-                d.fit();
+                d.sizeSet();
                 return;
             }
             const r = bounds(d, true);

package/dist/thread/player/scripting/lifecycle.js

@@ -45,7 +45,7 @@ export class Lifecycle {
      * order, as Flash dispatches them.
      */
     added(display) {
-        this.orphans.delete(display.serial);
+        this.dropOrphan(display.serial);
         this.dispatch(display.object, "added", true);
         if (this.onStage(display)) {
             this.eachObject(display, (o) => this.dispatch(o, "addedToStage", false));
@@ -136,6 +136,7 @@ export class Lifecycle {
     orphan(display, keep = true) {
         if (display.object && !this.orphans.has(display.serial)) {
             this.orphans.set(display.serial, { ref: display.ref, keep, since: this.s.frames });
+            this.sortedOrphans = null;
             scriptWork.changes++;
         }
     }
@@ -152,24 +153,42 @@ export class Lifecycle {
             display.fresh = true;
         }
     }
-    /** The orphans still there, newest first, as Flash runs their frames. */
-    orphanRoots() {
-        const roots = [];
-        for (const [serial, orphan] of this.orphans) {
-            const display = orphan.ref.deref();
+    /**
+     * The orphans, newest first, as Flash runs their frames: kept sorted
+     * until one comes or goes, as the player walks them twice a frame.
+     */
+    sortedOrphans = null;
+    dropOrphan(serial) {
+        if (this.orphans.delete(serial)) {
+            this.sortedOrphans = null;
+        }
+    }
+    /** Each orphan still there, newest first, to `f`, which must leave the orphans as they are. */
+    eachOrphanRoot(f) {
+        let sorted = this.sortedOrphans;
+        if (!sorted) {
+            sorted = [];
+            for (const [serial, orphan] of this.orphans) {
+                sorted.push({ serial, ref: orphan.ref });
+            }
+            sorted.sort((a, b) => b.serial - a.serial);
+            this.sortedOrphans = sorted;
+        }
+        for (let i = 0; i < sorted.length; i++) {
+            const display = sorted[i].ref.deref();
             if (!display) {
-                this.orphans.delete(serial);
+                this.dropOrphan(sorted[i].serial);
                 continue;
             }
-            roots.push(display);
+            f(display);
         }
-        return roots.sort((a, b) => b.serial - a.serial);
     }
     /** Whether `display` or anything under it listens for a frame's broadcast events. */
     hearsFrames(display) {
         if (display.object) {
-            for (const targets of this.s.broadcasts.values()) {
-                if (targets.has(display.object)) {
+            const sets = this.s.broadcastSets;
+            for (let i = 0; i < sets.length; i++) {
+                if (sets[i].has(display.object)) {
                     return true;
                 }
             }
@@ -187,7 +206,7 @@ export class Lifecycle {
      * does: timelines stopped, frame broadcasts no longer heard, no orphan.
      */
     stopAll(display) {
-        this.orphans.delete(display.serial);
+        this.dropOrphan(display.serial);
         stopTimelineSoundsUnder(this.s, display);
         const stop = (o) => {
             if (o instanceof MovieClip) {
@@ -230,24 +249,25 @@ export class Lifecycle {
         // What the timeline took off this frame has had its frame; it stops here. So
         // does one that has played ORPHAN_FRAMES off the list, but for one that
         // listens for a frame's events, which hold it in Flash too.
-        for (const [serial, orphan] of this.orphans) {
+        // forEach, as for-of makes an entry for each of what may be thousands, every frame.
+        this.orphans.forEach((orphan, serial) => {
             if (!orphan.keep) {
-                this.orphans.delete(serial);
-                continue;
+                this.dropOrphan(serial);
+                return;
             }
             if (this.s.frames - orphan.since < ORPHAN_FRAMES) {
-                continue;
+                return;
             }
             const display = orphan.ref.deref();
             if (display && this.hearsFrames(display)) {
                 orphan.since = this.s.frames;
-                continue;
+                return;
             }
-            this.orphans.delete(serial);
+            this.dropOrphan(serial);
             if (display) {
                 stopTimelineSoundsUnder(this.s, display);
             }
-        }
+        });
         // What scripts made this frame and left off the display list plays on as an orphan.
         const made = this.madeThisFrame.splice(0);
         if (made.length > 0) {

package/dist/thread/player/scripting.js

@@ -203,6 +203,8 @@ export class Scripting {
     inFrameScript = null;
     /** The display objects listening for each frame event, in the order they first listened; a broadcast reaches these. */
     broadcasts = new Map();
+    /** The same sets, for a walk by index that makes no iterator; the map never lets one go. */
+    broadcastSets = [];
     /** The dispatchers listening for ACTIVATE or DEACTIVATE, held weakly. */
     activation = new Map();
     /** What flash.display.Stage reports and sets; the player copies the frame rate back each frame. */
@@ -579,6 +581,7 @@ export class Scripting {
         if (!targets) {
             targets = new Set();
             this.broadcasts.set(type, targets);
+            this.broadcastSets.push(targets);
         }
         return targets;
     }
@@ -792,9 +795,7 @@ export class Scripting {
                 }
             }
         };
-        for (const orphan of this.lifecycle.orphanRoots()) {
-            visit(orphan);
-        }
+        this.lifecycle.eachOrphanRoot(visit);
         visit(root);
         for (const display of this.lifecycle.fresh) {
             visit(display);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swf2es/player-hosts",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "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.5"
+    "@swf2es/player": "0.1.6"
   }
 }