swf-toolkit 0.0.0-stage → 0.1.0

package/dist/assets/assets.js

@@ -0,0 +1,151 @@
+/**
+ * Export / replace SWF resources: bitmaps, sounds, binary data and edit-text strings.
+ */
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { ByteReader } from '../io/reader.js';
+import { ByteWriter } from '../io/writer.js';
+import { TagCode } from '../swf/tag-codes.js';
+import { DefineBinaryDataTag, RawTag, SymbolTableTag } from '../swf/tags.js';
+import { extractImage, IMAGE_TAGS, replaceImage } from './images.js';
+import { extractSound, replaceSound } from './sounds.js';
+export const ALL_ASSET_KINDS = ['images', 'sounds', 'binary', 'texts'];
+/** Class / export names per character id (SymbolClass + ExportAssets). */
+export function symbolNames(swf) {
+    const map = new Map();
+    for (const { tag } of swf.walkTags()) {
+        if (!(tag instanceof SymbolTableTag))
+            continue;
+        for (const s of tag.symbols)
+            map.set(s.id, [...(map.get(s.id) ?? []), s.name]);
+    }
+    return map;
+}
+/** Initial text of a DefineEditText tag (undefined when it has none). */
+export function editTextOf(tag) {
+    const r = new ByteReader(tag.data);
+    r.u16();
+    const bits = r.ub(5);
+    r.ub(bits * 4);
+    r.align();
+    const f1 = r.u8();
+    const f2 = r.u8();
+    if (f1 & 0x01)
+        r.u16();
+    if (f2 & 0x80)
+        r.cstring();
+    if (f1 & 0x01)
+        r.u16();
+    if (f1 & 0x04)
+        r.u32();
+    if (f1 & 0x02)
+        r.u16();
+    if (f2 & 0x20)
+        r.bytesView(9);
+    r.cstring(); // variable name
+    if (!(f1 & 0x80))
+        return undefined;
+    const offset = r.pos;
+    const text = r.cstring();
+    return { text, offset, end: r.pos };
+}
+/** Writes resources into `outDir/<kind>/<id>[_<symbol>].<ext>`. */
+export async function exportAssets(swf, outDir, kinds = ALL_ASSET_KINDS) {
+    const result = { files: [], skipped: [] };
+    const names = symbolNames(swf);
+    let jpegTables;
+    for (const { tag } of swf.walkTags()) {
+        if (tag.code === TagCode.JPEGTables && tag instanceof RawTag)
+            jpegTables = tag.data;
+    }
+    const fileName = (id, ext) => {
+        const sym = names.get(id)?.[0];
+        const safe = sym ? '_' + sym.replace(/[^A-Za-z0-9_.$-]/g, '_') : '';
+        return `${id}${safe}.${ext}`;
+    };
+    const write = async (kind, name, data) => {
+        const dir = join(outDir, kind);
+        await mkdir(dir, { recursive: true });
+        const p = join(dir, name);
+        await writeFile(p, data);
+        result.files.push(p);
+    };
+    for (const { tag } of swf.walkTags()) {
+        const id = tag.characterId;
+        if (id === undefined)
+            continue;
+        try {
+            if (kinds.includes('images') && IMAGE_TAGS.has(tag.code)) {
+                const img = extractImage(tag, jpegTables);
+                if (img) {
+                    await write('images', fileName(id, img.ext), img.data);
+                    if (img.alphaMask)
+                        await write('images', fileName(id, 'alpha.png'), img.alphaMask);
+                }
+            }
+            else if (kinds.includes('sounds') && tag.code === TagCode.DefineSound) {
+                const s = extractSound(tag);
+                if (s)
+                    await write('sounds', fileName(id, s.ext), s.data);
+            }
+            else if (kinds.includes('binary') && tag instanceof DefineBinaryDataTag) {
+                await write('binary', fileName(id, 'bin'), tag.data);
+            }
+            else if (kinds.includes('texts') && tag.code === TagCode.DefineEditText && tag instanceof RawTag) {
+                const t = editTextOf(tag);
+                if (t)
+                    await write('texts', fileName(id, 'txt'), t.text);
+            }
+        }
+        catch (e) {
+            result.skipped.push({ id, reason: e.message });
+        }
+    }
+    return result;
+}
+/** Replaces a DefineEditText's initial text. */
+export function replaceEditText(swf, id, text) {
+    for (const { tag } of swf.walkTags()) {
+        if (tag.characterId !== id || tag.code !== TagCode.DefineEditText || !(tag instanceof RawTag))
+            continue;
+        const t = editTextOf(tag);
+        const w = new ByteWriter(tag.data.length + text.length * 3);
+        if (t) {
+            w.bytes(tag.data.subarray(0, t.offset));
+            w.cstring(text);
+            w.bytes(tag.data.subarray(t.end));
+        }
+        else {
+            // Set HasText and append the text.
+            const data = tag.data.slice();
+            const r = new ByteReader(data);
+            r.u16();
+            const bits = r.ub(5);
+            r.ub(bits * 4);
+            r.align();
+            data[r.pos] |= 0x80;
+            w.bytes(data);
+            w.cstring(text);
+        }
+        tag.data = w.toBytes();
+        return tag;
+    }
+    throw new Error(`No DefineEditText with id ${id}`);
+}
+/** Replaces the resource with character `id` using a file's contents (type chosen by the tag). */
+export function replaceAsset(swf, id, file) {
+    const tag = swf.findCharacter(id);
+    if (!tag)
+        throw new Error(`No character with id ${id}`);
+    if (IMAGE_TAGS.has(tag.code))
+        return replaceImage(swf, id, file);
+    if (tag.code === TagCode.DefineSound)
+        return replaceSound(swf, id, file);
+    if (tag instanceof DefineBinaryDataTag) {
+        tag.data = file.slice();
+        return tag;
+    }
+    if (tag.code === TagCode.DefineEditText)
+        return replaceEditText(swf, id, new TextDecoder().decode(file));
+    throw new Error(`Replacing ${tag.name} (id ${id}) is not supported`);
+}

package/dist/assets/images.d.ts

@@ -0,0 +1,31 @@
+import type { Swf } from '../swf/swf.js';
+import { RawTag, type Tag } from '../swf/tags.js';
+import { type RgbaImage } from './png.js';
+export declare const IMAGE_TAGS: ReadonlySet<number>;
+export interface ExtractedImage {
+    id: number;
+    /** File extension: png, jpg or gif. */
+    ext: 'png' | 'jpg' | 'gif';
+    data: Uint8Array;
+    /** Alpha mask (grayscale PNG) for JPEG3/4 images. */
+    alphaMask?: Uint8Array;
+    width?: number;
+    height?: number;
+}
+/** Decodes DefineBitsLossless(2) pixel data to straight RGBA. */
+export declare function decodeLossless(tag: RawTag): RgbaImage;
+/** Extracts the image stored in a bitmap tag. */
+export declare function extractImage(tag: Tag, jpegTables?: Uint8Array): ExtractedImage | undefined;
+/** Reads width/height from a JPEG's SOF marker. */
+export declare function jpegSize(b: Uint8Array): {
+    width: number;
+    height: number;
+} | undefined;
+/** Builds a DefineBitsLossless2 tag body from an RGBA image. */
+export declare function encodeLossless2(id: number, img: RgbaImage): Uint8Array;
+/**
+ * Replaces the bitmap with character `id`. PNG files become
+ * DefineBitsLossless2 (exact pixels, alpha); JPEG / GIF files are stored
+ * as DefineBitsJPEG2.
+ */
+export declare function replaceImage(swf: Swf, id: number, file: Uint8Array): Tag;

package/dist/assets/images.js

@@ -0,0 +1,238 @@
+/**
+ * Bitmap tags ↔ image files.
+ *
+ * - DefineBitsLossless / DefineBitsLossless2 ↔ PNG (with alpha)
+ * - DefineBits (+ JPEGTables), DefineBitsJPEG2/3/4 → original JPEG / PNG / GIF data.
+ *   JPEG3/4 alpha channels are exported as a separate grayscale PNG mask.
+ */
+import { deflateSync, inflateSync } from 'node:zlib';
+import { ByteReader } from '../io/reader.js';
+import { ByteWriter } from '../io/writer.js';
+import { TagCode } from '../swf/tag-codes.js';
+import { RawTag } from '../swf/tags.js';
+import { decodePng, encodePng, isPng } from './png.js';
+export const IMAGE_TAGS = new Set([
+    TagCode.DefineBits,
+    TagCode.DefineBitsJPEG2,
+    TagCode.DefineBitsJPEG3,
+    TagCode.DefineBitsJPEG4,
+    TagCode.DefineBitsLossless,
+    TagCode.DefineBitsLossless2,
+]);
+function imageType(b) {
+    if (isPng(b))
+        return 'png';
+    if (b[0] === 0x47 && b[1] === 0x49 && b[2] === 0x46)
+        return 'gif';
+    return 'jpg';
+}
+/** Removes the erroneous `FF D9 FF D8` prefix some encoders emit and merges JPEGTables. */
+function cleanJpeg(data, tables) {
+    let d = data;
+    if (d[0] === 0xff && d[1] === 0xd9 && d[2] === 0xff && d[3] === 0xd8)
+        d = d.subarray(4);
+    // Some files contain an EOI/SOI pair in the middle (tables + image); remove it.
+    const parts = [];
+    if (tables && tables.length > 4) {
+        let t = tables;
+        if (t[0] === 0xff && t[1] === 0xd9 && t[2] === 0xff && t[3] === 0xd8)
+            t = t.subarray(4);
+        // tables: SOI ... EOI → drop trailing EOI; image: SOI ... → drop leading SOI
+        parts.push(t[t.length - 2] === 0xff && t[t.length - 1] === 0xd9 ? t.subarray(0, -2) : t);
+        parts.push(d[0] === 0xff && d[1] === 0xd8 ? d.subarray(2) : d);
+    }
+    else {
+        for (let i = 2; i + 3 < d.length; i++) {
+            if (d[i] === 0xff && d[i + 1] === 0xd9 && d[i + 2] === 0xff && d[i + 3] === 0xd8) {
+                parts.push(d.subarray(0, i), d.subarray(i + 4));
+                d = new Uint8Array(0);
+                break;
+            }
+        }
+        if (d.length)
+            parts.push(d);
+    }
+    const out = new Uint8Array(parts.reduce((a, p) => a + p.length, 0));
+    let o = 0;
+    for (const p of parts) {
+        out.set(p, o);
+        o += p.length;
+    }
+    return out;
+}
+/** Decodes DefineBitsLossless(2) pixel data to straight RGBA. */
+export function decodeLossless(tag) {
+    const r = new ByteReader(tag.data);
+    r.u16(); // id
+    const format = r.u8();
+    const width = r.u16();
+    const height = r.u16();
+    const alpha = tag.code === TagCode.DefineBitsLossless2;
+    const colorTableSize = format === 3 ? r.u8() + 1 : 0;
+    const pixels = new Uint8Array(inflateSync(r.rest()));
+    const out = new Uint8Array(width * height * 4);
+    const unpremul = (d) => {
+        const a = out[d + 3];
+        if (a > 0 && a < 255) {
+            out[d] = Math.min(255, Math.round((out[d] * 255) / a));
+            out[d + 1] = Math.min(255, Math.round((out[d + 1] * 255) / a));
+            out[d + 2] = Math.min(255, Math.round((out[d + 2] * 255) / a));
+        }
+    };
+    if (format === 3) {
+        const entry = alpha ? 4 : 3;
+        const table = pixels.subarray(0, colorTableSize * entry);
+        const stride = (width + 3) & ~3;
+        const base = colorTableSize * entry;
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const idx = pixels[base + y * stride + x];
+                const d = (y * width + x) * 4;
+                out[d] = table[idx * entry] ?? 0;
+                out[d + 1] = table[idx * entry + 1] ?? 0;
+                out[d + 2] = table[idx * entry + 2] ?? 0;
+                out[d + 3] = alpha ? (table[idx * entry + 3] ?? 255) : 255;
+                if (alpha)
+                    unpremul(d);
+            }
+        }
+    }
+    else if (format === 4) {
+        const stride = (width * 2 + 3) & ~3;
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const v = (pixels[y * stride + x * 2] << 8) | pixels[y * stride + x * 2 + 1];
+                const d = (y * width + x) * 4;
+                out[d] = ((v >> 10) & 0x1f) * 255 / 31;
+                out[d + 1] = ((v >> 5) & 0x1f) * 255 / 31;
+                out[d + 2] = (v & 0x1f) * 255 / 31;
+                out[d + 3] = 255;
+            }
+        }
+    }
+    else if (format === 5) {
+        for (let i = 0; i < width * height; i++) {
+            const s = i * 4;
+            out[s] = pixels[s + 1];
+            out[s + 1] = pixels[s + 2];
+            out[s + 2] = pixels[s + 3];
+            out[s + 3] = alpha ? pixels[s] : 255;
+            if (alpha)
+                unpremul(s);
+        }
+    }
+    else
+        throw new Error(`Unsupported lossless bitmap format ${format}`);
+    return { width, height, data: out };
+}
+/** Extracts the image stored in a bitmap tag. */
+export function extractImage(tag, jpegTables) {
+    if (!(tag instanceof RawTag) || !IMAGE_TAGS.has(tag.code))
+        return undefined;
+    const id = tag.characterId;
+    const r = new ByteReader(tag.data);
+    r.u16();
+    switch (tag.code) {
+        case TagCode.DefineBitsLossless:
+        case TagCode.DefineBitsLossless2: {
+            const img = decodeLossless(tag);
+            return { id, ext: 'png', data: encodePng(img), width: img.width, height: img.height };
+        }
+        case TagCode.DefineBits:
+            return { id, ext: 'jpg', data: cleanJpeg(r.rest(), jpegTables) };
+        case TagCode.DefineBitsJPEG2: {
+            const d = r.rest();
+            const ext = imageType(d);
+            return { id, ext, data: ext === 'jpg' ? cleanJpeg(d) : d.slice() };
+        }
+        case TagCode.DefineBitsJPEG3:
+        case TagCode.DefineBitsJPEG4: {
+            const alphaOffset = r.u32();
+            if (tag.code === TagCode.DefineBitsJPEG4)
+                r.u16(); // deblock
+            const d = r.bytesView(alphaOffset);
+            const ext = imageType(d);
+            const result = { id, ext, data: ext === 'jpg' ? cleanJpeg(d) : d.slice() };
+            const alphaZ = r.rest();
+            if (ext === 'jpg' && alphaZ.length) {
+                const dims = jpegSize(result.data);
+                if (dims) {
+                    const a = new Uint8Array(inflateSync(alphaZ));
+                    const rgba = new Uint8Array(dims.width * dims.height * 4);
+                    for (let i = 0; i < dims.width * dims.height; i++) {
+                        rgba[i * 4] = rgba[i * 4 + 1] = rgba[i * 4 + 2] = a[i] ?? 255;
+                        rgba[i * 4 + 3] = 255;
+                    }
+                    result.alphaMask = encodePng({ width: dims.width, height: dims.height, data: rgba });
+                    result.width = dims.width;
+                    result.height = dims.height;
+                }
+            }
+            return result;
+        }
+    }
+    return undefined;
+}
+/** Reads width/height from a JPEG's SOF marker. */
+export function jpegSize(b) {
+    let i = 2;
+    while (i + 9 < b.length) {
+        if (b[i] !== 0xff) {
+            i++;
+            continue;
+        }
+        const marker = b[i + 1];
+        if (marker === 0xd8 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) {
+            i += 2;
+            continue;
+        }
+        const len = (b[i + 2] << 8) | b[i + 3];
+        if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+            return { height: (b[i + 5] << 8) | b[i + 6], width: (b[i + 7] << 8) | b[i + 8] };
+        }
+        i += 2 + len;
+    }
+    return undefined;
+}
+/** Builds a DefineBitsLossless2 tag body from an RGBA image. */
+export function encodeLossless2(id, img) {
+    const { width, height, data } = img;
+    const argb = new Uint8Array(width * height * 4);
+    for (let i = 0; i < width * height; i++) {
+        const a = data[i * 4 + 3];
+        const s = i * 4;
+        argb[s] = a;
+        argb[s + 1] = Math.round((data[s] * a) / 255);
+        argb[s + 2] = Math.round((data[s + 1] * a) / 255);
+        argb[s + 3] = Math.round((data[s + 2] * a) / 255);
+    }
+    const w = new ByteWriter(argb.length / 2 + 16);
+    w.u16(id).u8(5).u16(width).u16(height);
+    w.bytes(new Uint8Array(deflateSync(argb, { level: 9 })));
+    return w.toBytes();
+}
+/**
+ * Replaces the bitmap with character `id`. PNG files become
+ * DefineBitsLossless2 (exact pixels, alpha); JPEG / GIF files are stored
+ * as DefineBitsJPEG2.
+ */
+export function replaceImage(swf, id, file) {
+    for (const { tag, parent, index } of swf.walkTags()) {
+        if (tag.characterId !== id)
+            continue;
+        if (!IMAGE_TAGS.has(tag.code))
+            throw new Error(`Character ${id} is a ${tag.name}, not a bitmap`);
+        let next;
+        if (isPng(file))
+            next = new RawTag(TagCode.DefineBitsLossless2, encodeLossless2(id, decodePng(file)));
+        else {
+            const w = new ByteWriter(file.length + 2);
+            w.u16(id).bytes(file);
+            next = new RawTag(TagCode.DefineBitsJPEG2, w.toBytes());
+        }
+        next.longHeader = true;
+        (parent ? parent.tags : swf.tags)[index] = next;
+        return next;
+    }
+    throw new Error(`No character with id ${id}`);
+}

package/dist/assets/png.d.ts

@@ -0,0 +1,12 @@
+export interface RgbaImage {
+    width: number;
+    height: number;
+    /** Straight (non-premultiplied) RGBA, row-major. */
+    data: Uint8Array;
+}
+export declare function crc32(data: Uint8Array, crc?: number): number;
+export declare function isPng(b: Uint8Array): boolean;
+export declare function encodePng(img: RgbaImage, options?: {
+    level?: number;
+}): Uint8Array;
+export declare function decodePng(bytes: Uint8Array): RgbaImage;

package/dist/assets/png.js

@@ -0,0 +1,196 @@
+/**
+ * Minimal PNG encoder / decoder (8-bit RGBA output, all standard colour types
+ * with bit depth 8 on input; 1/2/4-bit palette and grayscale also accepted).
+ */
+import { deflateSync, inflateSync } from 'node:zlib';
+const CRC_TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        t[n] = c >>> 0;
+    }
+    return t;
+})();
+export function crc32(data, crc = 0xffffffff) {
+    for (let i = 0; i < data.length; i++)
+        crc = CRC_TABLE[(crc ^ data[i]) & 0xff] ^ (crc >>> 8);
+    return crc >>> 0;
+}
+const SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+export function isPng(b) {
+    return SIGNATURE.every((v, i) => b[i] === v);
+}
+export function encodePng(img, options = {}) {
+    const { width, height, data } = img;
+    const stride = width * 4;
+    const raw = new Uint8Array((stride + 1) * height);
+    for (let y = 0; y < height; y++) {
+        raw[y * (stride + 1)] = 0; // filter: none
+        raw.set(data.subarray(y * stride, (y + 1) * stride), y * (stride + 1) + 1);
+    }
+    const idat = deflateSync(raw, { level: options.level ?? 9 });
+    const chunks = [];
+    const chunk = (type, body) => {
+        const out = new Uint8Array(12 + body.length);
+        const dv = new DataView(out.buffer);
+        dv.setUint32(0, body.length);
+        for (let i = 0; i < 4; i++)
+            out[4 + i] = type.charCodeAt(i);
+        out.set(body, 8);
+        dv.setUint32(8 + body.length, crc32(out.subarray(4, 8 + body.length)) ^ 0xffffffff);
+        chunks.push(out);
+    };
+    const ihdr = new Uint8Array(13);
+    const dv = new DataView(ihdr.buffer);
+    dv.setUint32(0, width);
+    dv.setUint32(4, height);
+    ihdr[8] = 8; // bit depth
+    ihdr[9] = 6; // RGBA
+    chunk('IHDR', ihdr);
+    chunk('IDAT', new Uint8Array(idat));
+    chunk('IEND', new Uint8Array(0));
+    const total = 8 + chunks.reduce((a, c) => a + c.length, 0);
+    const out = new Uint8Array(total);
+    out.set(SIGNATURE, 0);
+    let o = 8;
+    for (const c of chunks) {
+        out.set(c, o);
+        o += c.length;
+    }
+    return out;
+}
+function paeth(a, b, c) {
+    const p = a + b - c;
+    const pa = Math.abs(p - a);
+    const pb = Math.abs(p - b);
+    const pc = Math.abs(p - c);
+    return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+}
+export function decodePng(bytes) {
+    if (!isPng(bytes))
+        throw new Error('Not a PNG file');
+    const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let pos = 8;
+    let width = 0;
+    let height = 0;
+    let depth = 8;
+    let colorType = 6;
+    let interlace = 0;
+    let palette;
+    let trns;
+    const idat = [];
+    while (pos + 8 <= bytes.length) {
+        const len = dv.getUint32(pos);
+        const type = String.fromCharCode(...bytes.subarray(pos + 4, pos + 8));
+        const body = bytes.subarray(pos + 8, pos + 8 + len);
+        if (type === 'IHDR') {
+            width = dv.getUint32(pos + 8);
+            height = dv.getUint32(pos + 12);
+            depth = body[8];
+            colorType = body[9];
+            interlace = body[12];
+        }
+        else if (type === 'PLTE')
+            palette = body;
+        else if (type === 'tRNS')
+            trns = body;
+        else if (type === 'IDAT')
+            idat.push(body);
+        else if (type === 'IEND')
+            break;
+        pos += 12 + len;
+    }
+    if (interlace)
+        throw new Error('Interlaced PNG files are not supported');
+    if (depth === 16)
+        throw new Error('16-bit PNG files are not supported');
+    const channels = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 }[colorType];
+    if (!channels)
+        throw new Error(`Unsupported PNG colour type ${colorType}`);
+    const total = idat.reduce((a, c) => a + c.length, 0);
+    const z = new Uint8Array(total);
+    let o = 0;
+    for (const c of idat) {
+        z.set(c, o);
+        o += c.length;
+    }
+    const raw = new Uint8Array(inflateSync(z));
+    const bpp = Math.max(1, (channels * depth) >> 3);
+    const stride = Math.ceil((width * channels * depth) / 8);
+    const pixels = new Uint8Array(stride * height);
+    let prev = new Uint8Array(stride);
+    for (let y = 0; y < height; y++) {
+        const filter = raw[y * (stride + 1)];
+        const line = raw.subarray(y * (stride + 1) + 1, (y + 1) * (stride + 1));
+        const cur = pixels.subarray(y * stride, (y + 1) * stride);
+        for (let x = 0; x < stride; x++) {
+            const a = x >= bpp ? cur[x - bpp] : 0;
+            const b = prev[x];
+            const c = x >= bpp ? prev[x - bpp] : 0;
+            let v = line[x];
+            switch (filter) {
+                case 1:
+                    v += a;
+                    break;
+                case 2:
+                    v += b;
+                    break;
+                case 3:
+                    v += (a + b) >> 1;
+                    break;
+                case 4:
+                    v += paeth(a, b, c);
+                    break;
+            }
+            cur[x] = v & 0xff;
+        }
+        prev = cur;
+    }
+    const out = new Uint8Array(width * height * 4);
+    const sample = (row, i) => {
+        if (depth === 8)
+            return row[i];
+        const bit = i * depth;
+        return (row[bit >> 3] >> (8 - depth - (bit & 7))) & ((1 << depth) - 1);
+    };
+    const scale = depth === 8 ? 1 : 255 / ((1 << depth) - 1);
+    for (let y = 0; y < height; y++) {
+        const row = pixels.subarray(y * stride, (y + 1) * stride);
+        for (let x = 0; x < width; x++) {
+            const d = (y * width + x) * 4;
+            switch (colorType) {
+                case 0: {
+                    const g = sample(row, x);
+                    const v = Math.round(g * scale);
+                    out[d] = out[d + 1] = out[d + 2] = v;
+                    out[d + 3] = trns && trns.length >= 2 && ((trns[0] << 8) | trns[1]) === g ? 0 : 255;
+                    break;
+                }
+                case 2:
+                    out[d] = row[x * 3];
+                    out[d + 1] = row[x * 3 + 1];
+                    out[d + 2] = row[x * 3 + 2];
+                    out[d + 3] = 255;
+                    break;
+                case 3: {
+                    const idx = sample(row, x);
+                    out[d] = palette?.[idx * 3] ?? 0;
+                    out[d + 1] = palette?.[idx * 3 + 1] ?? 0;
+                    out[d + 2] = palette?.[idx * 3 + 2] ?? 0;
+                    out[d + 3] = trns && idx < trns.length ? trns[idx] : 255;
+                    break;
+                }
+                case 4:
+                    out[d] = out[d + 1] = out[d + 2] = row[x * 2];
+                    out[d + 3] = row[x * 2 + 1];
+                    break;
+                case 6:
+                    out.set(row.subarray(x * 4, x * 4 + 4), d);
+                    break;
+            }
+        }
+    }
+    return { width, height, data: out };
+}

package/dist/assets/sounds.d.ts

@@ -0,0 +1,37 @@
+import type { Swf } from '../swf/swf.js';
+import { RawTag, type Tag } from '../swf/tags.js';
+export declare const SOUND_RATES: number[];
+export interface SoundInfo {
+    id: number;
+    /** 0 native PCM, 1 ADPCM, 2 MP3, 3 PCM LE, 4-6 Nellymoser, 11 Speex. */
+    format: number;
+    rate: number;
+    bits: 8 | 16;
+    channels: 1 | 2;
+    sampleCount: number;
+    data: Uint8Array;
+}
+export declare function parseDefineSound(tag: RawTag): SoundInfo;
+export declare function encodeWav(pcm: Uint8Array, rate: number, channels: number, bits: number): Uint8Array;
+/** Decodes SWF ADPCM to 16-bit little-endian PCM. */
+export declare function decodeAdpcm(data: Uint8Array, channels: number, sampleCount: number): Uint8Array;
+export interface ExtractedSound {
+    id: number;
+    ext: 'mp3' | 'wav' | 'nelly' | 'speex';
+    data: Uint8Array;
+    info: Omit<SoundInfo, 'data'>;
+}
+export declare function extractSound(tag: Tag): ExtractedSound | undefined;
+export interface Mp3Info {
+    rate: number;
+    channels: 1 | 2;
+    sampleCount: number;
+    /** Offset of the first frame (after ID3v2). */
+    start: number;
+    end: number;
+}
+export declare function parseMp3(b: Uint8Array): Mp3Info;
+/** Builds a DefineSound body from an MP3 or WAV file. */
+export declare function encodeDefineSound(id: number, file: Uint8Array): Uint8Array;
+/** Replaces DefineSound `id` with an MP3 or WAV file. */
+export declare function replaceSound(swf: Swf, id: number, file: Uint8Array): Tag;