@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/format/shape.js

@@ -0,0 +1,411 @@
+// Shapes as DefineShape, DefineShape2, DefineShape3 and DefineShape4 hold
+// them (SWF specification, chapter 6): fill and line styles, then shape
+// records, edges in twips relative to the pen and style changes that move
+// it or switch styles, until an end record; and morph shapes, which hold
+// two such shapes to blend. The player turns the edges into closed paths
+// per fill; this file only decodes them.
+import { SwfReader } from "./swf.js";
+import { DefineMorphShape, DefineMorphShape2, DefineShape, DefineShape2, DefineShape3, DefineShape4, } from "./tags.js";
+export const IDENTITY = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+export function readMatrix(r) {
+    r.align();
+    const m = { ...IDENTITY };
+    if (r.ub(1)) {
+        const n = r.ub(5);
+        m.a = r.sb(n) / 65536;
+        m.d = r.sb(n) / 65536;
+    }
+    if (r.ub(1)) {
+        const n = r.ub(5);
+        m.b = r.sb(n) / 65536;
+        m.c = r.sb(n) / 65536;
+    }
+    const n = r.ub(5);
+    m.tx = r.sb(n);
+    m.ty = r.sb(n);
+    r.align();
+    return m;
+}
+export function readColorTransform(r, alpha) {
+    r.align();
+    const hasAdd = r.ub(1);
+    const hasMul = r.ub(1);
+    const n = r.ub(4);
+    const ct = { rMul: 1, gMul: 1, bMul: 1, aMul: 1, rAdd: 0, gAdd: 0, bAdd: 0, aAdd: 0 };
+    if (hasMul) {
+        ct.rMul = r.sb(n) / 256;
+        ct.gMul = r.sb(n) / 256;
+        ct.bMul = r.sb(n) / 256;
+        if (alpha) {
+            ct.aMul = r.sb(n) / 256;
+        }
+    }
+    if (hasAdd) {
+        ct.rAdd = r.sb(n);
+        ct.gAdd = r.sb(n);
+        ct.bAdd = r.sb(n);
+        if (alpha) {
+            ct.aAdd = r.sb(n);
+        }
+    }
+    r.align();
+    return ct;
+}
+/** RGB, or RGBA with alpha, as 0xAARRGGBB. */
+function readColor(r, alpha) {
+    const red = r.u8();
+    const green = r.u8();
+    const blue = r.u8();
+    const a = alpha ? r.u8() : 255;
+    return ((a << 24) | (red << 16) | (green << 8) | blue) >>> 0;
+}
+function readGradient(r, alpha, focal) {
+    const matrix = readMatrix(r);
+    r.align();
+    const spread = r.ub(2);
+    const interpolation = r.ub(2);
+    const count = r.ub(4);
+    const stops = [];
+    for (let i = 0; i < count; i++) {
+        stops.push({ ratio: r.u8(), color: readColor(r, alpha) });
+    }
+    const f = focal ? r.s16() : 0;
+    return { matrix, spread, interpolation, stops, focal: f / 256 };
+}
+function readFill(r, version) {
+    const alpha = version >= 3;
+    const type = r.u8();
+    if (type === 0x00) {
+        return { type: "solid", color: readColor(r, alpha) };
+    }
+    if (type === 0x10 || type === 0x12 || type === 0x13) {
+        const kind = type === 0x10 ? "linear" : type === 0x12 ? "radial" : "focal";
+        return { type: kind, gradient: readGradient(r, alpha, type === 0x13) };
+    }
+    // Bitmap fills 0x40 to 0x43: repeating or clipped, smoothed or not. Any
+    // other type byte reads as one too, rather than failing the shape.
+    const bitmap = r.u16();
+    const matrix = readMatrix(r);
+    return { type: "bitmap", bitmap, matrix, repeat: (type & 1) === 0, smooth: (type & 2) === 0 };
+}
+function readFills(r, version) {
+    let count = r.u8();
+    if (count === 0xff && version >= 2) {
+        count = r.u16();
+    }
+    const fills = [];
+    for (let i = 0; i < count && !r.overrun; i++) {
+        fills.push(readFill(r, version));
+    }
+    return fills;
+}
+/** A line of DefineShape to DefineShape3, or a MORPHLINESTYLE's start or end: round, its colour only. */
+function plainLine(width, color) {
+    return {
+        width,
+        color,
+        startCap: 0,
+        endCap: 0,
+        join: 0,
+        miterLimit: 3,
+        noHScale: false,
+        noVScale: false,
+        pixelHinting: false,
+        noClose: false,
+        fill: null,
+    };
+}
+/** LINESTYLE2's flags and miter limit, which MORPHLINESTYLE2 has too, before its fill or colour. */
+function readLineFlags(r) {
+    const startCap = r.ub(2);
+    const join = r.ub(2);
+    const hasFill = r.ub(1) === 1;
+    const noHScale = r.ub(1) === 1;
+    const noVScale = r.ub(1) === 1;
+    const pixelHinting = r.ub(1) === 1;
+    r.ub(5); // reserved: the flags fill two bytes, must be zero
+    const noClose = r.ub(1) === 1;
+    const endCap = r.ub(2);
+    const miterLimit = join === 2 ? r.u16() / 256 : 3;
+    return { startCap, endCap, join, miterLimit, noHScale, noVScale, pixelHinting, noClose, hasFill };
+}
+/** The colour a filled line stands for where only a colour is read. */
+function fillColor(fill) {
+    return fill.type === "solid"
+        ? fill.color
+        : fill.type === "bitmap"
+            ? 0xff000000
+            : (fill.gradient.stops[0]?.color ?? 0xff000000);
+}
+function readLines(r, version) {
+    let count = r.u8();
+    if (count === 0xff && version >= 2) {
+        count = r.u16();
+    }
+    const lines = [];
+    for (let i = 0; i < count && !r.overrun; i++) {
+        const width = r.u16();
+        if (version < 4) {
+            lines.push(plainLine(width, readColor(r, version >= 3)));
+            continue;
+        }
+        const { hasFill, ...flags } = readLineFlags(r);
+        const fill = hasFill ? readFill(r, version) : null;
+        const color = fill ? fillColor(fill) : readColor(r, true);
+        lines.push({ width, color, ...flags, fill });
+    }
+    return lines;
+}
+/** The records from the reader's position: fill and line bit counts first, then records to the end record. */
+export function readRecords(r, version) {
+    r.align();
+    let fillBits = r.ub(4);
+    let lineBits = r.ub(4);
+    const records = [];
+    for (;;) {
+        if (r.overrun) {
+            return { records, truncated: true };
+        }
+        if (r.ub(1)) {
+            // An edge.
+            const straight = r.ub(1);
+            const n = r.ub(4) + 2;
+            if (straight) {
+                const general = r.ub(1);
+                const vertical = general ? 0 : r.ub(1);
+                const dx = general || !vertical ? r.sb(n) : 0;
+                const dy = general || vertical ? r.sb(n) : 0;
+                records.push({ type: "line", dx, dy });
+            }
+            else {
+                records.push({ type: "curve", cx: r.sb(n), cy: r.sb(n), ax: r.sb(n), ay: r.sb(n) });
+            }
+            continue;
+        }
+        const flags = r.ub(5);
+        if (flags === 0) {
+            return { records, truncated: false };
+        }
+        let moveTo = null;
+        if (flags & 1) {
+            const n = r.ub(5);
+            moveTo = { x: r.sb(n), y: r.sb(n) };
+        }
+        const fill0 = flags & 2 ? r.ub(fillBits) : null;
+        const fill1 = flags & 4 ? r.ub(fillBits) : null;
+        const line = flags & 8 ? r.ub(lineBits) : null;
+        let styles = null;
+        if (flags & 16 && version >= 2) {
+            styles = { fills: readFills(r, version), lines: readLines(r, version) };
+            r.align();
+            fillBits = r.ub(4);
+            lineBits = r.ub(4);
+        }
+        records.push({ type: "style", moveTo, fill0, fill1, line, styles });
+    }
+}
+/**
+ * SWF 8 brought the unsmoothed bitmap fills (0x42, 0x43). In an older SWF
+ * Flash Player draws the others unsmoothed as well, still or moving, as
+ * Ruffle reads them; AIR's runtime smooths them (`avm1-bitmap-smoothing-swf7`).
+ */
+const SMOOTHED_FILLS_VERSION = 8;
+function unsmooth(fill) {
+    if (fill?.type === "bitmap") {
+        fill.smooth = false;
+    }
+}
+function unsmoothStyles(fills, lines) {
+    for (let i = 0; i < fills.length; i++) {
+        unsmooth(fills[i]);
+    }
+    for (let i = 0; i < lines.length; i++) {
+        unsmooth(lines[i].fill);
+    }
+}
+/**
+ * A DefineShape tag's body, of the version its code gives, from a SWF of
+ * `swfVersion`, which decides whether its bitmap fills may be smoothed.
+ */
+export function readShape(bytes, code, offset, length, swfVersion = SMOOTHED_FILLS_VERSION) {
+    const version = code === DefineShape ? 1 : code === DefineShape2 ? 2 : code === DefineShape3 ? 3 : 4;
+    if (code !== DefineShape &&
+        code !== DefineShape2 &&
+        code !== DefineShape3 &&
+        code !== DefineShape4) {
+        throw new Error(`tag ${code} is not a shape`);
+    }
+    const r = new SwfReader(bytes, offset, offset + length);
+    const id = r.u16();
+    const bounds = r.rect();
+    let edgeBounds = null;
+    if (version === 4) {
+        edgeBounds = r.rect();
+        r.u8();
+    }
+    const fills = readFills(r, version);
+    const lines = readLines(r, version);
+    const { records, truncated } = readRecords(r, version);
+    if (swfVersion < SMOOTHED_FILLS_VERSION) {
+        unsmoothStyles(fills, lines);
+        for (let i = 0; i < records.length; i++) {
+            const record = records[i];
+            if (record.type === "style" && record.styles) {
+                unsmoothStyles(record.styles.fills, record.styles.lines);
+            }
+        }
+    }
+    return { id, bounds, edgeBounds, fills, lines, records, truncated };
+}
+/** MORPHGRADIENT: both matrices, then each stop's start and end. */
+function readMorphGradient(r, focal) {
+    const startMatrix = readMatrix(r);
+    const endMatrix = readMatrix(r);
+    // The count's byte carries spread and interpolation as a shape's
+    // gradient's does, which Flash writes and reads alike.
+    const spread = r.ub(2);
+    const interpolation = r.ub(2);
+    const count = r.ub(4);
+    const startStops = [];
+    const endStops = [];
+    for (let i = 0; i < count; i++) {
+        startStops.push({ ratio: r.u8(), color: readColor(r, true) });
+        endStops.push({ ratio: r.u8(), color: readColor(r, true) });
+    }
+    const startFocal = focal ? r.s16() / 256 : 0;
+    const endFocal = focal ? r.s16() / 256 : 0;
+    return {
+        start: { matrix: startMatrix, spread, interpolation, stops: startStops, focal: startFocal },
+        end: { matrix: endMatrix, spread, interpolation, stops: endStops, focal: endFocal },
+    };
+}
+function readMorphFill(r) {
+    const type = r.u8();
+    if (type === 0x00) {
+        return {
+            start: { type: "solid", color: readColor(r, true) },
+            end: { type: "solid", color: readColor(r, true) },
+        };
+    }
+    if (type === 0x10 || type === 0x12 || type === 0x13) {
+        const kind = type === 0x10 ? "linear" : type === 0x12 ? "radial" : "focal";
+        const { start, end } = readMorphGradient(r, type === 0x13);
+        return { start: { type: kind, gradient: start }, end: { type: kind, gradient: end } };
+    }
+    const bitmap = r.u16();
+    const repeat = (type & 1) === 0;
+    const smooth = (type & 2) === 0;
+    return {
+        start: { type: "bitmap", bitmap, matrix: readMatrix(r), repeat, smooth },
+        end: { type: "bitmap", bitmap, matrix: readMatrix(r), repeat, smooth },
+    };
+}
+function readMorphFills(r) {
+    let count = r.u8();
+    if (count === 0xff) {
+        count = r.u16();
+    }
+    const fills = [];
+    for (let i = 0; i < count && !r.overrun; i++) {
+        fills.push(readMorphFill(r));
+    }
+    return fills;
+}
+/**
+ * MORPHLINESTYLE (version 1) or MORPHLINESTYLE2 (2): both widths, then colours, or flags and a
+ * fill.
+ */
+function readMorphLines(r, version) {
+    let count = r.u8();
+    if (count === 0xff) {
+        count = r.u16();
+    }
+    const lines = [];
+    for (let i = 0; i < count && !r.overrun; i++) {
+        const startWidth = r.u16();
+        const endWidth = r.u16();
+        if (version < 2) {
+            const startColor = readColor(r, true);
+            lines.push({
+                start: plainLine(startWidth, startColor),
+                end: plainLine(endWidth, readColor(r, true)),
+            });
+            continue;
+        }
+        const { hasFill, ...flags } = readLineFlags(r);
+        if (hasFill) {
+            const fill = readMorphFill(r);
+            lines.push({
+                start: { width: startWidth, color: fillColor(fill.start), ...flags, fill: fill.start },
+                end: { width: endWidth, color: fillColor(fill.end), ...flags, fill: fill.end },
+            });
+            continue;
+        }
+        const startColor = readColor(r, true);
+        const endColor = readColor(r, true);
+        lines.push({
+            start: { width: startWidth, color: startColor, ...flags, fill: null },
+            end: { width: endWidth, color: endColor, ...flags, fill: null },
+        });
+    }
+    return lines;
+}
+/**
+ * A DefineMorphShape or DefineMorphShape2 tag's body, of the version its
+ * code gives, from a SWF of `swfVersion` (as `readShape`).
+ */
+export function readMorphShape(bytes, code, offset, length, swfVersion = SMOOTHED_FILLS_VERSION) {
+    if (code !== DefineMorphShape && code !== DefineMorphShape2) {
+        throw new Error(`tag ${code} is not a morph shape`);
+    }
+    const version = code === DefineMorphShape ? 1 : 2;
+    const r = new SwfReader(bytes, offset, offset + length);
+    const id = r.u16();
+    const startBounds = r.rect();
+    const endBounds = r.rect();
+    let startEdgeBounds = null;
+    let endEdgeBounds = null;
+    if (version === 2) {
+        startEdgeBounds = r.rect();
+        endEdgeBounds = r.rect();
+        r.u8();
+    }
+    // The end's records are where the offset says, which may be past where
+    // the start's end when a tool pads them.
+    const endOffset = r.u32();
+    const endAt = r.pos + endOffset;
+    const fills = readMorphFills(r);
+    const lines = readMorphLines(r, version);
+    // The start's records stop at the end's, where the offset lies past the
+    // styles and in the tag: one missing its end record reads no further. A
+    // style change in either end's records brings no new styles: version 1
+    // reads none.
+    const offsetValid = endOffset !== 0 && endAt >= r.pos && endAt <= r.end;
+    const start = readRecords(offsetValid ? new SwfReader(r.bytes, r.pos, endAt) : r, 1);
+    if (offsetValid) {
+        r.pos = endAt;
+    }
+    const end = readRecords(r, 1);
+    if (swfVersion < SMOOTHED_FILLS_VERSION) {
+        for (let i = 0; i < fills.length; i++) {
+            unsmooth(fills[i].start);
+            unsmooth(fills[i].end);
+        }
+        for (let i = 0; i < lines.length; i++) {
+            unsmooth(lines[i].start.fill);
+            unsmooth(lines[i].end.fill);
+        }
+    }
+    return {
+        id,
+        startBounds,
+        endBounds,
+        startEdgeBounds,
+        endEdgeBounds,
+        fills,
+        lines,
+        start: start.records,
+        end: end.records,
+        truncated: start.truncated || end.truncated,
+    };
+}

package/dist/thread/format/sound.js

@@ -0,0 +1,91 @@
+// DefineSound's header and encoded samples, and the tags that play sounds
+// from a timeline: StartSound and StartSound2, the stream of
+// SoundStreamHead and SoundStreamBlock, and DefineButtonSound. Decoding
+// belongs to the player, where a host can supply an audio device.
+import { readString } from "./display.js";
+import { SwfReader } from "./swf.js";
+import { StartSound2 } from "./tags.js";
+const RATES = [5512.5, 11025, 22050, 44100];
+export function readSound(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    const id = r.u16();
+    const flags = r.u8();
+    const format = flags >> 4;
+    const sampleRate = RATES[(flags >> 2) & 3];
+    const sampleSize = (flags & 2) === 0 ? 8 : 16;
+    const channels = (flags & 1) === 0 ? 1 : 2;
+    const sampleCount = r.u32();
+    const seekSamples = format === 2 ? r.s16() : 0;
+    return {
+        id,
+        format,
+        sampleRate,
+        sampleSize,
+        channels,
+        sampleCount,
+        seekSamples,
+        data: bytes.subarray(r.pos, tag.offset + tag.length),
+    };
+}
+export function readSoundInfo(r) {
+    const flags = r.u8();
+    const inPoint = flags & 0x01 ? r.u32() : null;
+    const outPoint = flags & 0x02 ? r.u32() : null;
+    const loops = flags & 0x04 ? r.u16() : 1;
+    let envelope = null;
+    if (flags & 0x08) {
+        envelope = [];
+        for (let n = r.u8(); n > 0 && !r.overrun; n--) {
+            envelope.push({ sample: r.u32(), left: r.u16() / 32768, right: r.u16() / 32768 });
+        }
+    }
+    return {
+        stop: (flags & 0x20) !== 0,
+        noMultiple: (flags & 0x10) !== 0,
+        inPoint,
+        outPoint,
+        loops,
+        envelope,
+    };
+}
+export function readStartSound(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    if (tag.code === StartSound2) {
+        const className = readString(r);
+        return { id: null, className, info: readSoundInfo(r) };
+    }
+    const id = r.u16();
+    return { id, className: null, info: readSoundInfo(r) };
+}
+export function readSoundStreamHead(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    // The playback format is only a hint; the stream's own follows it.
+    r.u8();
+    const flags = r.u8();
+    return {
+        format: flags >> 4,
+        sampleRate: RATES[(flags >> 2) & 3],
+        sampleSize: (flags & 2) === 0 ? 8 : 16,
+        channels: (flags & 1) === 0 ? 1 : 2,
+        samplesPerBlock: r.u16(),
+    };
+}
+export function readSoundStreamBlock(bytes, tag, format) {
+    const end = tag.offset + tag.length;
+    if (format !== 2) {
+        return { sampleCount: null, data: bytes.subarray(tag.offset, end) };
+    }
+    const r = new SwfReader(bytes, tag.offset, end);
+    const sampleCount = r.u16();
+    return { sampleCount, data: bytes.subarray(Math.min(end, tag.offset + 4), end) };
+}
+export function readButtonSound(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    const id = r.u16();
+    const sounds = [];
+    for (let i = 0; i < 4; i++) {
+        const sound = r.pos + 2 <= r.end ? r.u16() : 0;
+        sounds.push(sound === 0 ? null : { id: sound, info: readSoundInfo(r) });
+    }
+    return { id, sounds };
+}

package/dist/thread/format/swf.js

@@ -0,0 +1,163 @@
+// A SWF's movie header and its tags, as the SWF file format specification
+// (version 19) lays them out: after the 8-byte file header and the body's
+// decompression, the frame size as a RECT, the frame rate as 8.8 fixed
+// point, the frame count, then tags to an End tag or the body's end.
+import { decompressSwf, decompressSwfPrefix } from "./compression.js";
+import { End, FileAttributes, SetBackgroundColor } from "./tags.js";
+const SIGNATURES = { FWS: "none", CWS: "zlib", ZWS: "lzma" };
+/** Read the 8-byte header every SWF starts with. */
+export function readSwfHeader(bytes) {
+    if (bytes.length < 8) {
+        throw new RangeError(`SWF header needs 8 bytes, got ${bytes.length}`);
+    }
+    const signature = String.fromCharCode(bytes[0], bytes[1], bytes[2]);
+    const compression = SIGNATURES[signature];
+    if (!compression) {
+        throw new TypeError(`Not a SWF file (signature ${JSON.stringify(signature)})`);
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return { compression, version: bytes[3], fileLength: view.getUint32(4, true) };
+}
+/** Reads bits and bytes of a SWF body, bits most significant first, as the format packs them. */
+export class SwfReader {
+    bytes;
+    pos;
+    end;
+    bit = 0;
+    byte = 0;
+    constructor(bytes, pos = 0, end = bytes.length) {
+        this.bytes = bytes;
+        this.pos = pos;
+        this.end = end;
+    }
+    /** Past the end: every read after it gives 0. */
+    get overrun() {
+        return this.pos > this.end;
+    }
+    align() {
+        this.bit = 0;
+    }
+    ub(n) {
+        let v = 0;
+        for (let i = 0; i < n; i++) {
+            if (this.bit === 0) {
+                this.byte = this.pos < this.end ? this.bytes[this.pos] : 0;
+                this.pos++;
+                this.bit = 8;
+            }
+            this.bit--;
+            v = v * 2 + ((this.byte >> this.bit) & 1);
+        }
+        return v;
+    }
+    sb(n) {
+        if (n > 0 && n <= 32 && n === (n | 0)) {
+            const shift = 32 - n;
+            return (this.ub(n) << shift) >> shift;
+        }
+        if (n === 0) {
+            return 0;
+        }
+        const v = this.ub(n);
+        return v >= 2 ** (n - 1) ? v - 2 ** n : v;
+    }
+    u8() {
+        this.align();
+        const v = this.pos < this.end ? this.bytes[this.pos] : 0;
+        this.pos++;
+        return v;
+    }
+    u16() {
+        return this.u8() | (this.u8() << 8);
+    }
+    u32() {
+        return (this.u16() | (this.u16() << 16)) >>> 0;
+    }
+    s16() {
+        return (this.u16() << 16) >> 16;
+    }
+    rect() {
+        this.align();
+        const n = this.ub(5);
+        const rect = { xMin: this.sb(n), xMax: this.sb(n), yMin: this.sb(n), yMax: this.sb(n) };
+        this.align();
+        return rect;
+    }
+}
+/** A SWF's header and tags, its body decompressed. */
+export function readSwf(file) {
+    const header = readSwfHeader(file);
+    const bytes = decompressSwf(file);
+    const r = new SwfReader(bytes, 8);
+    const frameSize = r.rect();
+    const frameRate = r.u16() / 256;
+    const frameCount = r.u16();
+    const { tags, truncated } = readTags(bytes, r.pos, bytes.length);
+    return { header, bytes, frameSize, frameRate, frameCount, tags, truncated };
+}
+/** The tags from `start` to an End tag or `end`, as a sprite's or the file's. */
+export function readTags(bytes, start, end) {
+    const tags = [];
+    const r = new SwfReader(bytes, start, end);
+    while (r.pos + 2 <= end) {
+        const codeAndLength = r.u16();
+        const code = codeAndLength >> 6;
+        let length = codeAndLength & 0x3f;
+        const long = length === 0x3f;
+        if (long) {
+            length = r.u32();
+        }
+        if (r.pos + length > end) {
+            tags.push({ code, offset: r.pos, length: Math.max(0, end - r.pos), long });
+            return { tags, truncated: true };
+        }
+        tags.push({ code, offset: r.pos, length, long });
+        r.pos += length;
+        if (code === End) {
+            break;
+        }
+    }
+    return { tags, truncated: false };
+}
+/** The background colour SetBackgroundColor sets, 0xRRGGBB, or white without one. */
+export function backgroundColor(swf) {
+    const tag = swf.tags.find((t) => t.code === SetBackgroundColor);
+    if (!tag || tag.length < 3) {
+        return 0xffffff;
+    }
+    const b = swf.bytes;
+    return (b[tag.offset] << 16) | (b[tag.offset + 1] << 8) | b[tag.offset + 2];
+}
+/**
+ * The flags of a SWF file's FileAttributes, from the start of the file
+ * alone, as Flash Player reads them, FileAttributes being the first tag:
+ * 0 for a SWF whose first tag is another. For a host that must not
+ * decompress the whole of a SWF it does not trust, as a desktop shell
+ * choosing a local SWF's sandbox; ActionScript3 is 0x08, UseNetwork 0x01.
+ */
+export function fileAttributes(file) {
+    // The header's rect is 17 bytes at most, then the rate, count, and a long tag header.
+    const bytes = decompressSwfPrefix(file, 64);
+    try {
+        const r = new SwfReader(bytes, 8);
+        r.rect();
+        r.u16();
+        r.u16();
+        const head = r.u16();
+        if (head >> 6 !== FileAttributes) {
+            return 0;
+        }
+        if ((head & 0x3f) === 0x3f) {
+            r.u32();
+        }
+        return r.u8();
+    }
+    catch {
+        return 0;
+    }
+}
+/** Whether FileAttributes marks the SWF as ActionScript 3; without the bit it is an AVM1 movie. */
+export function isAs3(swf) {
+    const tag = swf.tags.find((t) => t.code === FileAttributes);
+    return !!tag && tag.length >= 1 && (swf.bytes[tag.offset] & 0x08) !== 0;
+}