@swf2es/player-hosts 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,592 @@
+import { apply, concat } from "./geometry.js";
+import { CUBIC, CURVE, LINE, } from "./shapes.js";
+const TWIPS = 20;
+const IDENTITY_MATRIX = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+/** The matrix adl reads back for a gradient begun with none: a 200-pixel square about the origin. */
+const DEFAULT_GRADIENT = {
+    a: 100 / 819.2,
+    b: 0,
+    c: 0,
+    d: 100 / 819.2,
+    tx: 0,
+    ty: 0,
+};
+/** What a cubic may stray from the quadratics that stand for it, in twips, before it is split again. */
+const CUBIC_TOLERANCE = 50;
+/** A 0xAARRGGBB colour back from Flash's premultiplied store: the alpha a byte, each channel through it and back. */
+export function storedColor(argb) {
+    const a = argb >>> 24;
+    if (a === 0) {
+        return { color: 0, alpha: 0 };
+    }
+    // Fitted to all 256 levels of a channel at nine alphas in adl.
+    const back = Math.floor(65280 / a);
+    let color = 0;
+    for (const shift of [16, 8, 0]) {
+        const premultiplied = (((argb >>> shift) & 0xff) * (a + 1)) >> 8;
+        color |= Math.min(255, (premultiplied * back + 127) >> 8) << shift;
+    }
+    return { color, alpha: a / 255 };
+}
+function datumOf(paint, m, defaults) {
+    switch (paint.type) {
+        case "solid":
+            return { type: "solid", ...storedColor(paint.color) };
+        case "gradient": {
+            const g = concat(defaults.has(paint) ? DEFAULT_GRADIENT : paint.matrix, m);
+            // The linear part in single floats and the offset in whole pixels, toward zero.
+            return {
+                type: "gradient",
+                radial: paint.radial,
+                colors: paint.stops.map((s) => s.color >>> 0),
+                alphas: paint.stops.map((s) => (s.color >>> 24) / 255),
+                ratios: paint.stops.map((s) => s.ratio),
+                matrix: {
+                    a: Math.fround(g.a),
+                    b: Math.fround(g.b),
+                    c: Math.fround(g.c),
+                    d: Math.fround(g.d),
+                    tx: Math.trunc(g.tx),
+                    ty: Math.trunc(g.ty),
+                },
+                spread: paint.spread === 1 ? "reflect" : paint.spread === 2 ? "repeat" : "pad",
+                linearRgb: paint.linearRgb,
+                focal: paint.radial ? Math.round(Math.max(-1, Math.min(1, paint.focal)) * 255) / 255 : 0,
+            };
+        }
+        case "image": {
+            // A bitmap's matrix comes back 4095/4096 of itself, its offset in whole pixels.
+            const b = concat(paint.matrix, m);
+            const k = 4095 / 4096;
+            return {
+                type: "bitmap",
+                image: paint.image,
+                matrix: {
+                    a: Math.fround(b.a * k),
+                    b: Math.fround(b.b * k),
+                    c: Math.fround(b.c * k),
+                    d: Math.fround(b.d * k),
+                    tx: Math.round(b.tx * k),
+                    ty: Math.round(b.ty * k),
+                },
+            };
+        }
+        default:
+            return { type: "bitmap", image: null, matrix: IDENTITY_MATRIX };
+    }
+}
+/** A path as Flash writes it out, in twips: a move to where the pen is goes, and a curve along its chord is a line. */
+class Writer {
+    commands = [];
+    data = [];
+    x = Number.NaN;
+    y = Number.NaN;
+    move(x, y) {
+        if (x !== this.x || y !== this.y) {
+            this.commands.push(1);
+            this.to(x, y);
+        }
+    }
+    line(x, y) {
+        this.commands.push(2);
+        this.to(x, y);
+    }
+    curve(cx, cy, x, y) {
+        if (Math.abs(2 * cx - this.x - x) <= 1 && Math.abs(2 * cy - this.y - y) <= 1) {
+            this.line(x, y);
+            return;
+        }
+        this.commands.push(3);
+        this.data.push(cx / TWIPS, cy / TWIPS);
+        this.to(x, y);
+    }
+    to(x, y) {
+        this.data.push(x / TWIPS, y / TWIPS);
+        this.x = x;
+        this.y = y;
+    }
+}
+/**
+ * A cubic as Flash keeps it: split in halves until a quadratic for each
+ * part strays under the tolerance, the error going down eightfold with
+ * each halving, and each part the quadratic of its cubic's middle.
+ */
+function cubicSegments(out, p0, c1, c2, p3) {
+    const ex = p3[0] - 3 * c2[0] + 3 * c1[0] - p0[0];
+    const ey = p3[1] - 3 * c2[1] + 3 * c1[1] - p0[1];
+    const error = Math.hypot(ex, ey);
+    let n = 1;
+    while (error / n ** 3 > CUBIC_TOLERANCE && n < 1024) {
+        n *= 2;
+    }
+    const at = (t, k) => {
+        const u = 1 - t;
+        return u * u * u * p0[k] + 3 * u * u * t * c1[k] + 3 * u * t * t * c2[k] + t * t * t * p3[k];
+    };
+    const slope = (t, k) => {
+        const u = 1 - t;
+        return 3 * (u * u * (c1[k] - p0[k]) + 2 * u * t * (c2[k] - c1[k]) + t * t * (p3[k] - c2[k]));
+    };
+    let x = Math.round(p0[0]);
+    let y = Math.round(p0[1]);
+    for (let i = 0; i < n; i++) {
+        const t0 = i / n;
+        const t1 = (i + 1) / n;
+        const third = 1 / (3 * n);
+        const control = [0, 1].map((k) => {
+            const a = at(t0, k);
+            const d = at(t1, k);
+            return (3 * (a + slope(t0, k) * third + d - slope(t1, k) * third) - (a + d)) / 4;
+        });
+        const x1 = Math.round(at(t1, 0));
+        const y1 = Math.round(at(t1, 1));
+        out.push({
+            x0: x,
+            y0: y,
+            curve: true,
+            cx: Math.round(control[0]),
+            cy: Math.round(control[1]),
+            x1,
+            y1,
+        });
+        x = x1;
+        y = y1;
+    }
+}
+/** A path's segments through `m`, in whole twips. */
+function segmentsOf(path, m) {
+    const out = [];
+    const point = (i) => {
+        const [x, y] = apply(m, path[i], path[i + 1]);
+        return [x * TWIPS, y * TWIPS];
+    };
+    let [x, y] = point(1);
+    for (let i = 3; i < path.length;) {
+        const command = path[i];
+        if (command === LINE) {
+            const [x1, y1] = point(i + 1);
+            out.push({ x0: Math.round(x), y0: Math.round(y), curve: false, cx: 0, cy: 0, x1, y1 });
+            [x, y] = [x1, y1];
+            i += 3;
+        }
+        else if (command === CURVE) {
+            const [cx, cy] = point(i + 1);
+            const [x1, y1] = point(i + 3);
+            out.push({ x0: Math.round(x), y0: Math.round(y), curve: true, cx, cy, x1, y1 });
+            [x, y] = [x1, y1];
+            i += 5;
+        }
+        else if (command === CUBIC) {
+            const p3 = point(i + 5);
+            cubicSegments(out, [x, y], point(i + 1), point(i + 3), p3);
+            [x, y] = p3;
+            i += 7;
+        }
+        else {
+            break;
+        }
+    }
+    for (const s of out) {
+        s.cx = Math.round(s.cx);
+        s.cy = Math.round(s.cy);
+        s.x1 = Math.round(s.x1);
+        s.y1 = Math.round(s.y1);
+    }
+    return out;
+}
+function writeSegment(w, s) {
+    if (s.curve) {
+        w.curve(s.cx, s.cy, s.x1, s.y1);
+    }
+    else {
+        w.line(s.x1, s.y1);
+    }
+}
+/**
+ * A fill's contours in the order Flash links its edges back up: one that
+ * starts where the last ended follows it, before the rest in their order.
+ */
+function writeContours(w, contours, m) {
+    const left = contours.map((c) => segmentsOf(c, m)).filter((c) => c.length);
+    while (left.length) {
+        let next = left.findIndex((c) => c[0].x0 === w.x && c[0].y0 === w.y);
+        if (next < 0) {
+            next = 0;
+        }
+        writeContour(w, left.splice(next, 1)[0]);
+    }
+}
+/**
+ * A fill's contour, as Flash keeps it: one left open along a line, which
+ * encloses nothing, is dropped; one left open otherwise is closed with a
+ * line.
+ */
+function writeContour(w, segments) {
+    const first = segments[0];
+    const last = segments[segments.length - 1];
+    const closed = last.x1 === first.x0 && last.y1 === first.y0;
+    if (!closed && !bent(segments)) {
+        return;
+    }
+    w.move(first.x0, first.y0);
+    for (const s of segments) {
+        writeSegment(w, s);
+    }
+    if (!closed) {
+        w.line(first.x0, first.y0);
+    }
+}
+/** Whether a contour's points, control points too, leave the line through its first two. */
+function bent(segments) {
+    const x0 = segments[0].x0;
+    const y0 = segments[0].y0;
+    let dx = 0;
+    let dy = 0;
+    for (const s of segments) {
+        for (const [x, y] of s.curve
+            ? [
+                [s.cx, s.cy],
+                [s.x1, s.y1],
+            ]
+            : [[s.x1, s.y1]]) {
+            if (!dx && !dy) {
+                [dx, dy] = [x - x0, y - y0];
+            }
+            else if (dx * (y - y0) !== dy * (x - x0)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Lines thinner than a pixel and a half are a whole pixel or a hairline:
+ * adl strokes every line at its width rounded to a whole pixel, half to
+ * even, and a line that scales neither way a fifth as wide.
+ */
+function halfWidth(line) {
+    const pixels = line.width / TWIPS;
+    let whole = Math.round(pixels);
+    if (Math.abs(pixels % 1) === 0.5 && whole % 2) {
+        whole--;
+    }
+    return line.noHScale && line.noVScale ? whole * 2 : whole * 10;
+}
+const unit = (x, y) => {
+    const l = Math.hypot(x, y);
+    return l ? [x / l, y / l] : [0, 0];
+};
+/**
+ * The outline of a line's path, as Flash builds it to fill: from the end
+ * of the first segment's +n side back along it, around the start cap, out
+ * along every -n side to the end cap, and back along the +n sides; a path
+ * that ends where it starts is two contours instead, its +n sides and its
+ * -n sides, joined all around. Joins are drawn on the outer side of a
+ * turn, the inner side going straight across; round ones, and round caps,
+ * are arcs of at most 45° a quadratic, whose on-curve points lie halfway
+ * between their control points in whole twips.
+ */
+function writeStroke(w, segments, line) {
+    const h = halfWidth(line);
+    const hairline = h === 0;
+    const parts = [];
+    for (const s of segments) {
+        if (s.x0 === s.x1 && s.y0 === s.y1 && (!s.curve || (s.cx === s.x0 && s.cy === s.y0))) {
+            continue;
+        }
+        const t0 = s.curve && (s.cx !== s.x0 || s.cy !== s.y0)
+            ? unit(s.cx - s.x0, s.cy - s.y0)
+            : unit(s.x1 - s.x0, s.y1 - s.y0);
+        const t1 = s.curve && (s.cx !== s.x1 || s.cy !== s.y1)
+            ? unit(s.x1 - s.cx, s.y1 - s.cy)
+            : unit(s.x1 - s.x0, s.y1 - s.y0);
+        parts.push({
+            segment: s,
+            t0,
+            t1,
+            plus: offset(s, t0, t1, h, 1, hairline),
+            minus: offset(s, t0, t1, h, -1, hairline),
+        });
+    }
+    if (!parts.length) {
+        return;
+    }
+    const first = parts[0];
+    const last = parts[parts.length - 1];
+    const closed = parts.length > 1 &&
+        last.segment.x1 === first.segment.x0 &&
+        last.segment.y1 === first.segment.y0;
+    const cap = hairline ? 1 : line.startCap;
+    const join = hairline ? 1 : line.join;
+    const limit = Math.max(1, line.miterLimit);
+    // The inner side's joins that go nowhere, which Flash leaves to the end as contours of their own.
+    const stray = [];
+    const joinTo = (a, b, side, forward) => {
+        const s = a.segment;
+        const cross = a.t1[0] * b.t0[1] - a.t1[1] * b.t0[0];
+        const from = forward ? (side > 0 ? a.plus : a.minus) : side > 0 ? b.plus : b.minus;
+        const to = forward ? (side > 0 ? b.plus : b.minus) : side > 0 ? a.plus : a.minus;
+        const [fx, fy] = forward ? [from.x1, from.y1] : [from.x0, from.y0];
+        const [tx, ty] = forward ? [to.x0, to.y0] : [to.x1, to.y1];
+        const outer = (cross >= 0 ? 1 : -1) === side;
+        if (!outer || join === 1) {
+            if (!outer && tx === fx && ty === fy) {
+                stray.push([tx, ty]);
+            }
+            else {
+                w.line(tx, ty);
+            }
+            return;
+        }
+        // The turn, from a's normal on this side to b's.
+        const na = [a.t1[1] * side, -a.t1[0] * side];
+        const nb = [b.t0[1] * side, -b.t0[0] * side];
+        const turn = Math.atan2(na[0] * nb[1] - na[1] * nb[0], na[0] * nb[0] + na[1] * nb[1]);
+        if (join === 0) {
+            arc(w, s.x1, s.y1, h, forward ? turn : -turn, tx, ty);
+            return;
+        }
+        const points = miter(s.x1, s.y1, h, a, b, na, nb, Math.abs(turn), limit);
+        for (const [x, y] of forward ? points : points.reverse()) {
+            w.line(x, y);
+        }
+        w.line(tx, ty);
+    };
+    const capAt = (part, start) => {
+        const s = part.segment;
+        const [x, y] = start ? [s.x0, s.y0] : [s.x1, s.y1];
+        const t = start ? part.t0 : part.t1;
+        const from = start ? part.plus : part.minus;
+        const to = start ? part.minus : part.plus;
+        const [fx, fy] = start ? [from.x0, from.y0] : [from.x1, from.y1];
+        const [tx, ty] = start ? [to.x0, to.y0] : [to.x1, to.y1];
+        if (cap === 0) {
+            arc(w, x, y, h, -Math.PI, tx, ty);
+        }
+        else if (cap === 2) {
+            // The rounded sides moved on by the rounded half width.
+            const sign = start ? -1 : 1;
+            const dx = Math.round(t[0] * h) * sign;
+            const dy = Math.round(t[1] * h) * sign;
+            w.line(fx + dx, fy + dy);
+            w.line(tx + dx, ty + dy);
+            w.line(tx, ty);
+        }
+        else {
+            w.line(tx, ty);
+        }
+    };
+    const back = (side) => {
+        if (side.curve) {
+            w.curve(side.cx, side.cy, side.x0, side.y0);
+        }
+        else {
+            w.line(side.x0, side.y0);
+        }
+    };
+    const on = (side) => {
+        if (side.curve) {
+            w.curve(side.cx, side.cy, side.x1, side.y1);
+        }
+        else {
+            w.line(side.x1, side.y1);
+        }
+    };
+    w.move(first.plus.x1, first.plus.y1);
+    back(first.plus);
+    if (closed) {
+        joinTo(last, first, 1, false);
+    }
+    else {
+        capAt(first, true);
+        for (let i = 0; i < parts.length; i++) {
+            on(parts[i].minus);
+            if (i + 1 < parts.length) {
+                joinTo(parts[i], parts[i + 1], -1, true);
+            }
+        }
+        capAt(last, false);
+    }
+    for (let i = parts.length - 1; i > 0; i--) {
+        back(parts[i].plus);
+        joinTo(parts[i - 1], parts[i], 1, false);
+    }
+    if (closed) {
+        w.move(first.minus.x0, first.minus.y0);
+        for (let i = 0; i < parts.length; i++) {
+            on(parts[i].minus);
+            joinTo(parts[i], parts[(i + 1) % parts.length], -1, true);
+        }
+    }
+    for (const [x, y] of stray) {
+        w.move(x, y);
+        w.line(x, y);
+    }
+}
+/**
+ * A segment's side `sign` (+1 for +n), `h` twips out: its ends moved
+ * along their normals rounded to whole twips, a curve's control point
+ * where the moved tangents meet. A hairline's sides are the segment and
+ * the segment a twip across its run, right or down.
+ */
+function offset(s, t0, t1, h, sign, hairline) {
+    if (hairline) {
+        const [ox, oy] = Math.abs(s.x1 - s.x0) >= Math.abs(s.y1 - s.y0) ? [0, 1] : [1, 0];
+        const normal = ox * t0[1] - oy * t0[0];
+        const k = normal * sign > 0 ? 1 : 0;
+        return {
+            x0: s.x0 + ox * k,
+            y0: s.y0 + oy * k,
+            curve: s.curve,
+            cx: s.cx + ox * k,
+            cy: s.cy + oy * k,
+            x1: s.x1 + ox * k,
+            y1: s.y1 + oy * k,
+        };
+    }
+    const n0x = Math.round(t0[1] * h) * sign;
+    const n0y = Math.round(-t0[0] * h) * sign;
+    const n1x = Math.round(t1[1] * h) * sign;
+    const n1y = Math.round(-t1[0] * h) * sign;
+    const side = {
+        x0: s.x0 + n0x,
+        y0: s.y0 + n0y,
+        curve: s.curve,
+        cx: 0,
+        cy: 0,
+        x1: s.x1 + n1x,
+        y1: s.y1 + n1y,
+    };
+    if (s.curve) {
+        const cross = t0[0] * t1[1] - t0[1] * t1[0];
+        if (Math.abs(cross) < 1e-9) {
+            side.cx = s.cx + n0x;
+            side.cy = s.cy + n0y;
+        }
+        else {
+            const u = ((side.x1 - side.x0) * t1[1] - (side.y1 - side.y0) * t1[0]) / cross;
+            side.cx = Math.round(side.x0 + t0[0] * u);
+            side.cy = Math.round(side.y0 + t0[1] * u);
+        }
+    }
+    return side;
+}
+/**
+ * An arc about (`x`, `y`) of radius `r` from the pen, turning `sweep`, to
+ * the end (`ex`, `ey`), in quadratics of at most 45° each: control points
+ * where the tangents meet, rounded, and the on-curve points between them
+ * halfway, in whole twips down. The arc starts toward the pen as rounded,
+ * which comes nearer adl's than the exact angle does, but adl's control
+ * points still differ from these by a twip at some angles.
+ */
+function arc(w, x, y, r, sweep, ex, ey) {
+    const angle = Math.atan2(w.y - y, w.x - x);
+    const pieces = Math.ceil(Math.abs(sweep) / (Math.PI / 4) - 1e-9);
+    if (pieces === 0) {
+        w.line(ex, ey);
+        return;
+    }
+    const step = sweep / pieces;
+    const reach = r / Math.cos(step / 2);
+    const controls = [];
+    for (let i = 0; i < pieces; i++) {
+        const a = angle + step * (i + 0.5);
+        controls.push([Math.round(x + reach * Math.cos(a)), Math.round(y + reach * Math.sin(a))]);
+    }
+    for (let i = 0; i < pieces; i++) {
+        const [cx, cy] = controls[i];
+        const next = controls[i + 1];
+        if (next) {
+            w.curve(cx, cy, Math.floor((cx + next[0]) / 2), Math.floor((cy + next[1]) / 2));
+        }
+        else {
+            w.curve(cx, cy, ex, ey);
+        }
+    }
+}
+/**
+ * The points a miter join goes through between its sides: its tip, or
+ * where the limit, `limit` half widths out along the bisector, cuts it.
+ */
+function miter(x, y, h, a, b, na, nb, turn, limit) {
+    let [bx, by] = unit(na[0] + nb[0], na[1] + nb[1]);
+    if (!bx && !by) {
+        [bx, by] = unit(a.t1[0] - b.t0[0], a.t1[1] - b.t0[1]);
+    }
+    const ratio = 1 / Math.cos(turn / 2);
+    if (ratio <= limit) {
+        return [[Math.round(x + bx * h * ratio), Math.round(y + by * h * ratio)]];
+    }
+    const reach = limit * h;
+    const cut = (px, py, dx, dy) => {
+        const along = dx * bx + dy * by;
+        const t = along ? (reach - (px * bx + py * by)) / along : 0;
+        return [Math.round(x + px + dx * t), Math.round(y + py + dy * t)];
+    };
+    return [
+        cut(na[0] * h, na[1] * h, a.t1[0], a.t1[1]),
+        cut(nb[0] * h, nb[1] * h, -b.t0[0], -b.t0[1]),
+    ];
+}
+/** A stroke's path `at` and the lines closing fills that go on from its end. */
+function strokeSegments(path, closes, at, m) {
+    const segments = segmentsOf(path, m);
+    for (const close of closes) {
+        if (close.at !== at) {
+            continue;
+        }
+        const end = segments.length
+            ? [segments[segments.length - 1].x1, segments[segments.length - 1].y1]
+            : (() => {
+                const [x, y] = apply(m, path[1], path[2]);
+                return [Math.round(x * TWIPS), Math.round(y * TWIPS)];
+            })();
+        const [x, y] = apply(m, close.x, close.y);
+        segments.push({
+            x0: end[0],
+            y0: end[1],
+            curve: false,
+            cx: 0,
+            cy: 0,
+            x1: Math.round(x * TWIPS),
+            y1: Math.round(y * TWIPS),
+        });
+    }
+    return segments;
+}
+/**
+ * The layers' data, as seen through `m`, onto `out`. `defaults` holds the
+ * gradients beginGradientFill was given no matrix for.
+ */
+export function graphicsData(layers, m, defaults, out) {
+    for (const layer of layers) {
+        for (const fill of layer.fills) {
+            const w = new Writer();
+            writeContours(w, fill.contours, m);
+            if (w.commands.length) {
+                out.push(datumOf(fill.fill, m, defaults));
+                out.push({ type: "path", winding: fill.winding, commands: w.commands, data: w.data });
+                out.push({ type: "end" });
+            }
+        }
+        // A drawTriangles' textured triangles are left out, as adl leaves them, and their lines are
+        // one path.
+        for (const stroke of layer.strokes) {
+            let w = new Writer();
+            for (const [i, path] of stroke.paths.entries()) {
+                writeStroke(w, strokeSegments(path, stroke.closes ?? [], i, m), stroke.line);
+                if (!stroke.triangles || i === stroke.paths.length - 1) {
+                    writeLine(out, w, stroke.line);
+                    w = new Writer();
+                }
+            }
+        }
+    }
+}
+function writeLine(out, w, line) {
+    if (w.commands.length) {
+        out.push({ type: "solid", ...storedColor(line.color) });
+        out.push({ type: "path", winding: "nonZero", commands: w.commands, data: w.data });
+        out.push({ type: "end" });
+    }
+}

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

@@ -0,0 +1,71 @@
+// What a character makes: the display object a timeline places for it,
+// and its bringing to life once placed.
+import { BitmapStore } from "../bitmap/bitmap.js";
+import { BitmapObject } from "./bitmapobject.js";
+import { ButtonObject, buttonStates } from "./buttonobject.js";
+import { MovieClip } from "./movieclip.js";
+import { ShapeObject } from "./shapeobject.js";
+import { StaticTextObject, TextObject } from "./textobjects.js";
+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;
+    }
+    const clip = new MovieClip(character.timeline, library);
+    clip.character = character;
+    clip.scale9Grid = character.grid;
+    return clip;
+}
+/**
+ * Bring a display object the timeline placed to life: its AS3 object
+ * constructed where the SWF has scripts, which enters a clip's first frame
+ * and names it on its parent, else a clip's first frame entered. After the
+ * placement, as Flash has it, so that the parent and the name are there.
+ */
+export function construct(display, character, library) {
+    library.avm1?.made(display);
+    if (library.construct) {
+        library.construct(display, character);
+    }
+    else if (display instanceof MovieClip) {
+        display.enterFirstFrame();
+    }
+    else if (display instanceof ButtonObject && character.type === "button") {
+        buttonStates(display, character, library, (d, c) => construct(d, c, library), () => { });
+    }
+}
+/** A display object for a character as the timeline would place it, alive, but in no container. */
+export function instantiate(character, library) {
+    const display = displayFor(character, library);
+    construct(display, character, library);
+    return display;
+}