@swf2es/player-hosts 0.1.4 → 0.1.6

package/dist/thread/player/bitmap/pixel-bender.js

@@ -767,7 +767,10 @@ export class PixelBender {
         }
     }
 }
-/** A float as a bitmap's byte: clamped, NaN as 0, then rounded to the nearest, a half to the even. */
+/**
+ * A float as a bitmap's byte: clamped, NaN as 0, then rounded to the nearest, a half to the even.
+ * @public tests/player/pixel-bender.ts imports it into Chrome by name.
+ */
 export function outputByte(v) {
     const c = v > 0 ? (v < 1 ? v : 1) : 0;
     return nearest(Math.fround(c * 255));

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/displayobject.js

@@ -12,7 +12,7 @@ export const TRANSFORM = 1;
 export const CHILDREN = 2;
 export const CONTENT = 4;
 /** A Bitmap's pixels changed in place: the texture uploads again, nothing is rebuilt. */
-export const PIXELS = 8;
+const PIXELS = 8;
 /**
  * A count that moves whenever something changes that a round of frame
  * scripts (Scripting.runFrameScripts) reads to find a script to run: a

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/instantiate.js

@@ -10,35 +10,34 @@ import { INVALID_PIXELS } from "./timeline.js";
 /** A display object for a character, before its first frame: a shape, or a clip. */
 /** `hasImage` is PlaceObject3's flag where a timeline places it, which a bitmap's construction reads. */
 export function displayFor(character, library, hasImage = false) {
-    if (character.type === "shape") {
-        return new ShapeObject(character);
-    }
-    if (character.type === "morph") {
-        return ShapeObject.ofMorph(character);
-    }
-    if (character.type === "bitmap") {
-        // With scripts, its Bitmap's constructor gives it its data; without, a copy of the pixels.
-        const bitmap = new BitmapObject(library.construct ? null : BitmapStore.of(character.pixels ?? INVALID_PIXELS));
-        bitmap.character = character;
-        bitmap.hasImage = hasImage;
-        return bitmap;
-    }
-    if (character.type === "static") {
-        return new StaticTextObject(character, library.characters);
-    }
-    if (character.type === "text") {
-        const text = new TextObject(character);
-        text.fonts = library.fonts;
-        return text;
-    }
-    // Its states are made where it is constructed (Scripting.construct).
-    if (character.type === "button") {
-        const button = new ButtonObject();
-        button.character = character;
-        button.library = library;
-        button.trackAsMenu = character.trackAsMenu;
-        button.scale9Grid = character.grid;
-        return button;
+    switch (character.type) {
+        case "shape":
+            return new ShapeObject(character);
+        case "morph":
+            return ShapeObject.ofMorph(character);
+        case "bitmap": {
+            // With scripts, its Bitmap's constructor gives it its data; without, a copy of the pixels.
+            const bitmap = new BitmapObject(library.construct ? null : BitmapStore.of(character.pixels ?? INVALID_PIXELS));
+            bitmap.character = character;
+            bitmap.hasImage = hasImage;
+            return bitmap;
+        }
+        case "static":
+            return new StaticTextObject(character, library.characters);
+        case "text": {
+            const text = new TextObject(character);
+            text.fonts = library.fonts;
+            return text;
+        }
+        // Its states are made where it is constructed (Scripting.construct).
+        case "button": {
+            const button = new ButtonObject();
+            button.character = character;
+            button.library = library;
+            button.trackAsMenu = character.trackAsMenu;
+            button.scale9Grid = character.grid;
+            return button;
+        }
     }
     const clip = new MovieClip(character.timeline, library);
     clip.character = character;

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/desktop/NativeApplication.js

@@ -13,7 +13,7 @@ import { nativeWindowOf } from "../display/NativeWindow.js";
 import { addListener, removeListener } from "../events/EventDispatcher.js";
 import { fileAt } from "../filesystem/File.js";
 /** NativeApplication.runtimeVersion, and its patch level: the AIR these natives follow. */
-export const AIR_RUNTIME_VERSION = "51.3.1.2";
+const AIR_RUNTIME_VERSION = "51.3.1.2";
 const AIR_PATCH_LEVEL = 2;
 const INVOKE = "invoke";
 export function nativeApplicationNatives(s) {

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

@@ -3,9 +3,10 @@
 // ArgumentError 2015 for a size it refuses and for a store disposed.
 import { avm2 } from "../../../../runtime/index.js";
 import { BitmapStore, pixelRect, spanRect } from "../../../bitmap/bitmap.js";
+import { drawBitmap } from "../../../bitmap/composite.js";
 import { drawDisplayObject } from "../../../bitmap/draw.js";
 import { applyFilter, filterRefusal, filtersDrawn, GLOWS, generatedRect, } from "../../../bitmap/filters.js";
-import { alphaAt, colorBounds, colorTransform, comparePixels, copyChannel, drawBitmap, floodFill, histogram, isThresholdOperation, merge, noise, paletteMap, perlinNoise, pixelDissolve, scroll, threshold, } from "../../../bitmap/ops.js";
+import { alphaAt, colorBounds, colorTransform, comparePixels, copyChannel, floodFill, histogram, isThresholdOperation, merge, noise, paletteMap, perlinNoise, pixelDissolve, scroll, threshold, } from "../../../bitmap/ops.js";
 import { shaderFilter } from "../../../bitmap/pixel-bender.js";
 import { encodePng } from "../../../bitmap/png.js";
 import { INVALID_PIXELS } from "../../../display/timeline.js";
@@ -74,7 +75,7 @@ function sourceOf(s, v) {
 }
 /**
  * draw: a BitmapData, or a Bitmap as its data, its own transform ignored,
- * composited on the CPU (bitmap/ops.ts drawBitmap); any other display
+ * composited on the CPU (bitmap/composite.ts); any other display
  * object rendered by the Scripting's drawer at `samples` a side, over its
  * own bounds alone, then composited the same way. A null source is
  * ArgumentError 2005, as Flash words it.

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/playerglobal/flash/display/SimpleButton.js

@@ -24,17 +24,18 @@ export function simpleButtonNatives(s) {
         if (d?.parent && d.parent !== b && !d.encloses(b)) {
             d.parent.removeChild(d);
         }
-        if (state === "up") {
-            b.upState = d;
-        }
-        else if (state === "over") {
-            b.overState = d;
-        }
-        else if (state === "down") {
-            b.downState = d;
-        }
-        else {
-            b.hitTestState = d;
+        switch (state) {
+            case "up":
+                b.upState = d;
+                break;
+            case "over":
+                b.overState = d;
+                break;
+            case "down":
+                b.downState = d;
+                break;
+            default:
+                b.hitTestState = d;
         }
         b.show();
         // adl reports #2150 as an error nothing caught, from the setter of the state the button

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

@@ -41,12 +41,9 @@ export function stageNatives(s) {
             s.invalidated = true;
         }
         get scaleMode() {
-            return s.liveStageLayout ? s.stageScaleMode : "showAll";
+            return s.stageScaleMode;
         }
         set scaleMode(v) {
-            if (!s.liveStageLayout) {
-                return;
-            }
             if (v == null) {
                 throw s.rt.error("TypeError", 2007, "scaleMode");
             }
@@ -67,12 +64,9 @@ export function stageNatives(s) {
             }
         }
         get align() {
-            return s.liveStageLayout ? s.stageAlign : "";
+            return s.stageAlign;
         }
         set align(v) {
-            if (!s.liveStageLayout) {
-                return;
-            }
             if (v == null) {
                 throw s.rt.error("TypeError", 2007, "align");
             }

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

@@ -29,7 +29,7 @@ export function kernelOfShader(shader) {
  * number, or ArgumentError 2004, as many as its type holds, 0 past the
  * Array's end.
  */
-export function parameterValues(s, data, p) {
+function parameterValues(s, data, p) {
     const classes = shaderClasses(s);
     const size = PBJ_TYPE_SIZES[p.type] ?? 0;
     const float = pbjFloatType(p.type);

package/dist/thread/player/playerglobal/flash/filesystem/paths.js

@@ -151,6 +151,6 @@ export class NativePaths {
     }
 }
 /** A path segment in a URL: UTF-8, percent-encoded as adl writes them ("#?%" and spaces among them). */
-export function encodeSegment(segment) {
+function encodeSegment(segment) {
     return encodeURIComponent(segment);
 }